cfe414cc8a
Change-Id: I2b9d88a78e73065d65b1722d363e8492f80438c9 Reviewed-on: https://gerrit.libreoffice.org/25017 Reviewed-by: Ashod Nakashian <ashnakash@gmail.com> Tested-by: Ashod Nakashian <ashnakash@gmail.com>
435 lines
16 KiB
C++
435 lines
16 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <Poco/Net/WebSocket.h>
|
|
#include <cppunit/extensions/HelperMacros.h>
|
|
|
|
#include <TileCache.hpp>
|
|
|
|
#include <Common.hpp>
|
|
#include <Unit.hpp>
|
|
#include <Util.hpp>
|
|
#include <LOOLProtocol.hpp>
|
|
#include "helpers.hpp"
|
|
|
|
using namespace helpers;
|
|
|
|
/// TileCache unit-tests.
|
|
class TileCacheTests : public CPPUNIT_NS::TestFixture
|
|
{
|
|
const Poco::URI _uri;
|
|
Poco::Net::HTTPResponse _response;
|
|
|
|
CPPUNIT_TEST_SUITE(TileCacheTests);
|
|
|
|
CPPUNIT_TEST(testSimple);
|
|
CPPUNIT_TEST(testSimpleCombine);
|
|
CPPUNIT_TEST(testUnresponsiveClient);
|
|
CPPUNIT_TEST(testClientPartImpress);
|
|
CPPUNIT_TEST(testClientPartCalc);
|
|
#if ENABLE_DEBUG
|
|
CPPUNIT_TEST(testSimultaneousTilesRenderedJustOnce);
|
|
#endif
|
|
|
|
CPPUNIT_TEST_SUITE_END();
|
|
|
|
void testSimple();
|
|
void testSimpleCombine();
|
|
void testUnresponsiveClient();
|
|
void testClientPartImpress();
|
|
void testClientPartCalc();
|
|
void testSimultaneousTilesRenderedJustOnce();
|
|
|
|
void checkTiles(Poco::Net::WebSocket& socket,
|
|
const std::string& type);
|
|
|
|
void requestTiles(Poco::Net::WebSocket& socket,
|
|
const int part,
|
|
const int docWidth,
|
|
const int docHeight);
|
|
|
|
static
|
|
std::vector<char> genRandomData(const size_t size)
|
|
{
|
|
std::vector<char> v(size);
|
|
v.resize(size);
|
|
auto data = v.data();
|
|
for (size_t i = 0; i < size; ++i)
|
|
{
|
|
data[i] = static_cast<char>(Util::rng::getNext());
|
|
}
|
|
|
|
return v;
|
|
}
|
|
|
|
static
|
|
std::vector<char> readDataFromFile(std::unique_ptr<std::fstream>& file)
|
|
{
|
|
file->seekg(0, std::ios_base::end);
|
|
const std::streamsize size = file->tellg();
|
|
|
|
std::vector<char> v;
|
|
v.resize(size);
|
|
|
|
file->seekg(0, std::ios_base::beg);
|
|
file->read(v.data(), size);
|
|
|
|
return v;
|
|
}
|
|
|
|
public:
|
|
TileCacheTests()
|
|
: _uri(helpers::getTestServerURI())
|
|
{
|
|
#if ENABLE_SSL
|
|
Poco::Net::initializeSSL();
|
|
// Just accept the certificate anyway for testing purposes
|
|
Poco::SharedPtr<Poco::Net::InvalidCertificateHandler> invalidCertHandler = new Poco::Net::AcceptCertificateHandler(false);
|
|
Poco::Net::Context::Params sslParams;
|
|
Poco::Net::Context::Ptr sslContext = new Poco::Net::Context(Poco::Net::Context::CLIENT_USE, sslParams);
|
|
Poco::Net::SSLManager::instance().initializeClient(0, invalidCertHandler, sslContext);
|
|
#endif
|
|
}
|
|
|
|
#if ENABLE_SSL
|
|
~TileCacheTests()
|
|
{
|
|
Poco::Net::uninitializeSSL();
|
|
}
|
|
#endif
|
|
};
|
|
|
|
void TileCacheTests::testSimple()
|
|
{
|
|
if (!UnitWSD::init(UnitWSD::UnitType::TYPE_WSD, ""))
|
|
{
|
|
throw std::runtime_error("Failed to load wsd unit test library.");
|
|
}
|
|
|
|
// Create TileCache and pretend the file was modified as recently as
|
|
// now, so it discards the cached data.
|
|
TileCache tc("doc.ods", Poco::Timestamp(), "/tmp/tile_cache_tests");
|
|
|
|
int part = 0;
|
|
int width = 256;
|
|
int height = 256;
|
|
int tilePosX = 0;
|
|
int tilePosY = 0;
|
|
int tileWidth = 3840;
|
|
int tileHeight = 3840;
|
|
|
|
// No Cache
|
|
auto file = tc.lookupTile(part, width, height, tilePosX, tilePosY, tileWidth, tileHeight);
|
|
CPPUNIT_ASSERT_MESSAGE("found tile when none was expected", !file);
|
|
|
|
// Cache Tile
|
|
const auto size = 1024;
|
|
const auto data = genRandomData(size);
|
|
tc.saveTile(part, width, height, tilePosX, tilePosY, tileWidth, tileHeight, data.data(), size);
|
|
|
|
// Find Tile
|
|
file = tc.lookupTile(part, width, height, tilePosX, tilePosY, tileWidth, tileHeight);
|
|
CPPUNIT_ASSERT_MESSAGE("tile not found when expected", file && file->is_open());
|
|
const auto tileData = readDataFromFile(file);
|
|
CPPUNIT_ASSERT_MESSAGE("cached tile corrupted", data == tileData);
|
|
|
|
// Invalidate Tiles
|
|
tc.invalidateTiles("invalidatetiles: EMPTY");
|
|
|
|
// No Cache
|
|
file = tc.lookupTile(part, width, height, tilePosX, tilePosY, tileWidth, tileHeight);
|
|
CPPUNIT_ASSERT_MESSAGE("found tile when none was expected", !file);
|
|
}
|
|
|
|
void TileCacheTests::testSimpleCombine()
|
|
{
|
|
std::string documentPath, documentURL;
|
|
getDocumentPathAndURL("hello.odt", documentPath, documentURL);
|
|
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_GET, documentURL);
|
|
|
|
auto socket1 = *loadDocAndGetSocket(_uri, documentURL, "simpleCombine-1 ");
|
|
|
|
getResponseMessage(socket1, "invalidatetiles");
|
|
|
|
sendTextFrame(socket1, "tilecombine part=0 width=256 height=256 tileposx=0,3840 tileposy=0,0 tilewidth=3840 tileheight=3840");
|
|
|
|
auto tile1a = getResponseMessage(socket1, "tile:");
|
|
CPPUNIT_ASSERT_MESSAGE("did not receive a tile: message as expected", !tile1a.empty());
|
|
auto tile1b = getResponseMessage(socket1, "tile:");
|
|
CPPUNIT_ASSERT_MESSAGE("did not receive a tile: message as expected", !tile1b.empty());
|
|
sendTextFrame(socket1, "tilecombine part=0 width=256 height=256 tileposx=0,3840 tileposy=0,0 tilewidth=3840 tileheight=3840");
|
|
|
|
tile1a = getResponseMessage(socket1, "tile:");
|
|
CPPUNIT_ASSERT_MESSAGE("did not receive a tile: message as expected", !tile1a.empty());
|
|
tile1b = getResponseMessage(socket1, "tile:");
|
|
CPPUNIT_ASSERT_MESSAGE("did not receive a tile: message as expected", !tile1b.empty());
|
|
|
|
std::cerr << "Connecting second client." << std::endl;
|
|
auto socket2 = *loadDocAndGetSocket(_uri, documentURL, "simpleCombine-2 ", true);
|
|
sendTextFrame(socket2, "tilecombine part=0 width=256 height=256 tileposx=0,3840 tileposy=0,0 tilewidth=3840 tileheight=3840");
|
|
|
|
auto tile2a = getResponseMessage(socket2, "tile:");
|
|
CPPUNIT_ASSERT_MESSAGE("did not receive a tile: message as expected", !tile2a.empty());
|
|
auto tile2b = getResponseMessage(socket2, "tile:");
|
|
CPPUNIT_ASSERT_MESSAGE("did not receive a tile: message as expected", !tile2b.empty());
|
|
|
|
socket1.shutdown();
|
|
socket2.shutdown();
|
|
}
|
|
|
|
void TileCacheTests::testUnresponsiveClient()
|
|
{
|
|
std::string documentPath, documentURL;
|
|
getDocumentPathAndURL("hello.odt", documentPath, documentURL);
|
|
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_GET, documentURL);
|
|
|
|
auto socket1 = *loadDocAndGetSocket(_uri, documentURL, "unresponsiveClient-1 ");
|
|
|
|
getResponseMessage(socket1, "invalidatetiles");
|
|
|
|
std::cerr << "Connecting second client." << std::endl;
|
|
auto socket2 = *loadDocAndGetSocket(_uri, documentURL, "unresponsiveClient-2 ", true);
|
|
|
|
// Pathologically request tiles and fail to read (say slow connection).
|
|
// Meanwhile, verify that others can get all tiles fine.
|
|
// TODO: Track memory consumption to verify we don't buffer too much.
|
|
for (auto x = 0; x < 5; ++x)
|
|
{
|
|
// As for tiles and don't read!
|
|
sendTextFrame(socket1, "tilecombine part=0 width=256 height=256 tileposx=0,3840,7680,11520,0,3840,7680,11520 tileposy=0,0,0,0,3840,3840,3840,3840 tilewidth=3840 tileheight=3840");
|
|
|
|
// Verify that we get all 8 tiles.
|
|
sendTextFrame(socket2, "tilecombine part=0 width=256 height=256 tileposx=0,3840,7680,11520,0,3840,7680,11520 tileposy=0,0,0,0,3840,3840,3840,3840 tilewidth=3840 tileheight=3840");
|
|
for (auto i = 0; i < 8; ++i)
|
|
{
|
|
auto tile = getResponseMessage(socket2, "tile:");
|
|
CPPUNIT_ASSERT_MESSAGE("did not receive a tile: message as expected", !tile.empty());
|
|
}
|
|
}
|
|
|
|
socket1.shutdown();
|
|
socket2.shutdown();
|
|
}
|
|
|
|
void TileCacheTests::testClientPartImpress()
|
|
{
|
|
try
|
|
{
|
|
// Load a document
|
|
std::string documentPath, documentURL;
|
|
getDocumentPathAndURL("setclientpart.odp", documentPath, documentURL);
|
|
|
|
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_GET, documentURL);
|
|
Poco::Net::WebSocket socket = *connectLOKit(_uri, request, _response);
|
|
|
|
sendTextFrame(socket, "load url=" + documentURL);
|
|
CPPUNIT_ASSERT_MESSAGE("cannot load the document " + documentURL, isDocumentLoaded(socket));
|
|
|
|
checkTiles(socket, "presentation");
|
|
|
|
socket.shutdown();
|
|
Util::removeFile(documentPath);
|
|
}
|
|
catch (const Poco::Exception& exc)
|
|
{
|
|
CPPUNIT_FAIL(exc.displayText());
|
|
}
|
|
}
|
|
|
|
void TileCacheTests::testClientPartCalc()
|
|
{
|
|
try
|
|
{
|
|
// Load a document
|
|
std::string documentPath, documentURL;
|
|
getDocumentPathAndURL("setclientpart.ods", documentPath, documentURL);
|
|
|
|
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_GET, documentURL);
|
|
Poco::Net::WebSocket socket = *connectLOKit(_uri, request, _response);
|
|
|
|
sendTextFrame(socket, "load url=" + documentURL);
|
|
CPPUNIT_ASSERT_MESSAGE("cannot load the document " + documentURL, isDocumentLoaded(socket));
|
|
|
|
checkTiles(socket, "spreadsheet");
|
|
|
|
socket.shutdown();
|
|
Util::removeFile(documentPath);
|
|
}
|
|
catch (const Poco::Exception& exc)
|
|
{
|
|
CPPUNIT_FAIL(exc.displayText());
|
|
}
|
|
}
|
|
|
|
void TileCacheTests::testSimultaneousTilesRenderedJustOnce()
|
|
{
|
|
std::string documentPath, documentURL;
|
|
getDocumentPathAndURL("hello.odt", documentPath, documentURL);
|
|
|
|
Poco::Net::HTTPRequest request(Poco::Net::HTTPRequest::HTTP_GET, documentURL);
|
|
Poco::Net::WebSocket socket1 = *connectLOKit(_uri, request, _response);
|
|
sendTextFrame(socket1, "load url=" + documentURL);
|
|
|
|
Poco::Net::WebSocket socket2 = *connectLOKit(_uri, request, _response);
|
|
sendTextFrame(socket2, "load url=" + documentURL);
|
|
|
|
sendTextFrame(socket1, "tile part=42 width=400 height=400 tileposx=1000 tileposy=2000 tilewidth=3000 tileheight=3000");
|
|
sendTextFrame(socket2, "tile part=42 width=400 height=400 tileposx=1000 tileposy=2000 tilewidth=3000 tileheight=3000");
|
|
|
|
std::string response1;
|
|
getResponseMessage(socket1, "tile:", response1, true);
|
|
CPPUNIT_ASSERT_MESSAGE("did not receive a tile: message as expected", !response1.empty());
|
|
|
|
std::string response2;
|
|
getResponseMessage(socket2, "tile:", response2, true);
|
|
CPPUNIT_ASSERT_MESSAGE("did not receive a tile: message as expected", !response2.empty());
|
|
|
|
if (!response1.empty() && !response2.empty())
|
|
{
|
|
Poco::StringTokenizer tokens1(response1, " ");
|
|
std::string renderId1;
|
|
LOOLProtocol::getTokenString(tokens1, "renderid", renderId1);
|
|
Poco::StringTokenizer tokens2(response2, " ");
|
|
std::string renderId2;
|
|
LOOLProtocol::getTokenString(tokens2, "renderid", renderId2);
|
|
|
|
CPPUNIT_ASSERT(renderId1 == renderId2 ||
|
|
(renderId1 == "cached" && renderId2 != "cached") ||
|
|
(renderId1 != "cached" && renderId2 == "cached"));
|
|
}
|
|
|
|
socket1.shutdown();
|
|
socket2.shutdown();
|
|
}
|
|
|
|
void TileCacheTests::checkTiles(Poco::Net::WebSocket& socket, const std::string& docType)
|
|
{
|
|
const std::string current = "current=";
|
|
const std::string height = "height=";
|
|
const std::string parts = "parts=";
|
|
const std::string type = "type=";
|
|
const std::string width = "width=";
|
|
|
|
int currentPart = -1;
|
|
int totalParts = 0;
|
|
int docHeight = 0;
|
|
int docWidth = 0;
|
|
|
|
std::string response;
|
|
std::string text;
|
|
|
|
// check total slides 10
|
|
sendTextFrame(socket, "status");
|
|
getResponseMessage(socket, "status:", response, false);
|
|
CPPUNIT_ASSERT_MESSAGE("did not receive a status: message as expected", !response.empty());
|
|
{
|
|
std::cout << "status: " << response << std::endl;
|
|
Poco::StringTokenizer tokens(response, " ", Poco::StringTokenizer::TOK_IGNORE_EMPTY | Poco::StringTokenizer::TOK_TRIM);
|
|
CPPUNIT_ASSERT_EQUAL(static_cast<size_t>(5), tokens.count());
|
|
|
|
// Expected format is something like 'type= parts= current= width= height='.
|
|
text = tokens[0].substr(type.size());
|
|
totalParts = std::stoi(tokens[1].substr(parts.size()));
|
|
currentPart = std::stoi(tokens[2].substr(current.size()));
|
|
docWidth = std::stoi(tokens[3].substr(width.size()));
|
|
docHeight = std::stoi(tokens[4].substr(height.size()));
|
|
CPPUNIT_ASSERT_EQUAL(docType, text);
|
|
CPPUNIT_ASSERT_EQUAL(10, totalParts);
|
|
CPPUNIT_ASSERT(currentPart > -1);
|
|
CPPUNIT_ASSERT(docWidth > 0);
|
|
CPPUNIT_ASSERT(docHeight > 0);
|
|
}
|
|
|
|
if (docType == "presentation")
|
|
{
|
|
// request tiles
|
|
requestTiles(socket, currentPart, docWidth, docHeight);
|
|
}
|
|
|
|
// random setclientpart
|
|
std::srand(std::time(0));
|
|
std::vector<int> vParts = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
|
|
std::random_shuffle (vParts.begin(), vParts.end());
|
|
for (auto it : vParts)
|
|
{
|
|
if (currentPart != it)
|
|
{
|
|
// change part
|
|
text = Poco::format("setclientpart part=%d", it);
|
|
std::cout << text << std::endl;
|
|
sendTextFrame(socket, text);
|
|
requestTiles(socket, it, docWidth, docHeight);
|
|
}
|
|
currentPart = it;
|
|
}
|
|
}
|
|
|
|
void TileCacheTests::requestTiles(Poco::Net::WebSocket& socket, const int part, const int docWidth, const int docHeight)
|
|
{
|
|
// twips
|
|
const int tileSize = 3840;
|
|
// pixel
|
|
const int pixTileSize = 256;
|
|
|
|
int rows;
|
|
int cols;
|
|
int tileX;
|
|
int tileY;
|
|
int tileWidth;
|
|
int tileHeight;
|
|
|
|
std::string text;
|
|
std::string tile;
|
|
|
|
rows = docHeight / tileSize;
|
|
cols = docWidth / tileSize;
|
|
|
|
// Note: this code tests tile requests in the wrong way.
|
|
|
|
// This code does NOT match what was the idea how the LOOL protocol should/could be used. The
|
|
// intent was never that the protocol would need to be, or should be, used in a strict
|
|
// request/reply fashion. If a client needs n tiles, it should just send the requests, one after
|
|
// another. There is no need to do n roundtrips. A client should all the time be reading
|
|
// incoming messages, and handle incoming tiles as appropriate. There should be no expectation
|
|
// that tiles arrive at the client in the same order that they were requested.
|
|
|
|
// But, whatever.
|
|
|
|
for (int itRow = 0; itRow < rows; ++itRow)
|
|
{
|
|
for (int itCol = 0; itCol < cols; ++itCol)
|
|
{
|
|
tileWidth = tileSize;
|
|
tileHeight = tileSize;
|
|
tileX = tileSize * itCol;
|
|
tileY = tileSize * itRow;
|
|
text = Poco::format("tile part=%d width=%d height=%d tileposx=%d tileposy=%d tilewidth=%d tileheight=%d",
|
|
part, pixTileSize, pixTileSize, tileX, tileY, tileWidth, tileHeight);
|
|
|
|
sendTextFrame(socket, text);
|
|
tile = assertResponseLine(socket, "tile:", "requestTiles ");
|
|
// expected tile: part= width= height= tileposx= tileposy= tilewidth= tileheight=
|
|
Poco::StringTokenizer tokens(tile, " ", Poco::StringTokenizer::TOK_IGNORE_EMPTY | Poco::StringTokenizer::TOK_TRIM);
|
|
CPPUNIT_ASSERT_EQUAL(std::string("tile:"), tokens[0]);
|
|
CPPUNIT_ASSERT_EQUAL(part, std::stoi(tokens[1].substr(std::string("part=").size())));
|
|
CPPUNIT_ASSERT_EQUAL(pixTileSize, std::stoi(tokens[2].substr(std::string("width=").size())));
|
|
CPPUNIT_ASSERT_EQUAL(pixTileSize, std::stoi(tokens[3].substr(std::string("height=").size())));
|
|
CPPUNIT_ASSERT_EQUAL(tileX, std::stoi(tokens[4].substr(std::string("tileposx=").size())));
|
|
CPPUNIT_ASSERT_EQUAL(tileY, std::stoi(tokens[5].substr(std::string("tileposy=").size())));
|
|
CPPUNIT_ASSERT_EQUAL(tileWidth, std::stoi(tokens[6].substr(std::string("tileWidth=").size())));
|
|
CPPUNIT_ASSERT_EQUAL(tileHeight, std::stoi(tokens[7].substr(std::string("tileHeight=").size())));
|
|
}
|
|
}
|
|
}
|
|
|
|
CPPUNIT_TEST_SUITE_REGISTRATION(TileCacheTests);
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|