diff options
Diffstat (limited to 'tests/unit')
| -rw-r--r-- | tests/unit/CMakeLists.txt | 42 | ||||
| -rw-r--r-- | tests/unit/configargs.cxx | 325 | ||||
| -rw-r--r-- | tests/unit/conv.cxx | 187 | ||||
| -rw-r--r-- | tests/unit/convertlf.cxx | 137 | ||||
| -rw-r--r-- | tests/unit/emulatemb.cxx | 460 | ||||
| -rw-r--r-- | tests/unit/gesturehandler.cxx | 856 | ||||
| -rw-r--r-- | tests/unit/hostport.cxx | 159 | ||||
| -rw-r--r-- | tests/unit/parameters.cxx | 839 | ||||
| -rw-r--r-- | tests/unit/pixelformat.cxx | 279 | ||||
| -rw-r--r-- | tests/unit/shortcuthandler.cxx | 607 | ||||
| -rw-r--r-- | tests/unit/unicode.cxx | 274 |
11 files changed, 2847 insertions, 1318 deletions
diff --git a/tests/unit/CMakeLists.txt b/tests/unit/CMakeLists.txt index 8e223052..1e40a645 100644 --- a/tests/unit/CMakeLists.txt +++ b/tests/unit/CMakeLists.txt @@ -1,24 +1,50 @@ +include(GoogleTest) + +# Google Test requires a new C++ standard +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++17") + +enable_testing() + include_directories(${CMAKE_SOURCE_DIR}/common) include_directories(${CMAKE_SOURCE_DIR}/vncviewer) +add_executable(configargs configargs.cxx) +target_link_libraries(configargs rfb GTest::gtest_main) +gtest_discover_tests(configargs) + add_executable(conv conv.cxx) -target_link_libraries(conv rfb) +target_link_libraries(conv rfb GTest::gtest_main) +gtest_discover_tests(conv) add_executable(convertlf convertlf.cxx) -target_link_libraries(convertlf rfb) +target_link_libraries(convertlf core GTest::gtest_main) +gtest_discover_tests(convertlf) add_executable(gesturehandler gesturehandler.cxx ../../vncviewer/GestureHandler.cxx) -target_link_libraries(gesturehandler rfb) +target_link_libraries(gesturehandler core GTest::gtest_main) +gtest_discover_tests(gesturehandler) add_executable(hostport hostport.cxx) -target_link_libraries(hostport rfb) +target_link_libraries(hostport network GTest::gtest_main) +gtest_discover_tests(hostport) + +add_executable(parameters parameters.cxx) +target_link_libraries(parameters core GTest::gtest_main) +gtest_discover_tests(parameters) add_executable(pixelformat pixelformat.cxx) -target_link_libraries(pixelformat rfb) +target_link_libraries(pixelformat rfb GTest::gtest_main) +gtest_discover_tests(pixelformat) + +add_executable(shortcuthandler shortcuthandler.cxx ../../vncviewer/ShortcutHandler.cxx) +target_link_libraries(shortcuthandler core ${Intl_LIBRARIES} GTest::gtest_main) +gtest_discover_tests(shortcuthandler) add_executable(unicode unicode.cxx) -target_link_libraries(unicode rfb) +target_link_libraries(unicode core GTest::gtest_main) +gtest_discover_tests(unicode) add_executable(emulatemb emulatemb.cxx ../../vncviewer/EmulateMB.cxx) -target_include_directories(emulatemb SYSTEM PUBLIC ${GETTEXT_INCLUDE_DIR}) -target_link_libraries(emulatemb rfb ${GETTEXT_LIBRARIES}) +target_include_directories(emulatemb SYSTEM PUBLIC ${Intl_INCLUDE_DIR}) +target_link_libraries(emulatemb core ${Intl_LIBRARIES} GTest::gtest_main) +gtest_discover_tests(emulatemb) diff --git a/tests/unit/configargs.cxx b/tests/unit/configargs.cxx new file mode 100644 index 00000000..2d3406f3 --- /dev/null +++ b/tests/unit/configargs.cxx @@ -0,0 +1,325 @@ +/* Copyright 2025 Pierre Ossman <ossman@cendio.se> for Cendio AB + * + * This is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <gtest/gtest.h> + +#include <core/Configuration.h> + +static core::BoolParameter boolparam("boolparam", "", false); +static core::IntParameter intparam("intparam", "", 0); +static core::StringParameter strparam("strparam", "", ""); + +TEST(ConfigArgs, args) +{ + int ret; + std::vector<const char*> argv; + + boolparam.setParam(true); + intparam.setParam(1); + strparam.setParam("test"); + + // Just program name + argv = {"prog" }; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 0); + EXPECT_EQ(ret, 0); + EXPECT_EQ(boolparam, true); + EXPECT_EQ(intparam, 1); + EXPECT_STREQ(strparam, "test"); + + // A bunch of standard arguments + argv = {"prog", "arg1", "arg2", "arg3" }; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 2); + EXPECT_EQ(ret, 0); + EXPECT_EQ(boolparam, true); + EXPECT_EQ(intparam, 1); + EXPECT_STREQ(strparam, "test"); + + // A parameter without any dash + argv = {"prog", "strparam", "intparam" }; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 0); + EXPECT_EQ(boolparam, true); + EXPECT_EQ(intparam, 1); + EXPECT_STREQ(strparam, "test"); +} + +TEST(ConfigArgs, noDash) +{ + int ret; + std::vector<const char*> argv; + + boolparam.setParam(true); + intparam.setParam(1); + strparam.setParam("test"); + + // int argument + argv = {"prog", "intparam=12", "34"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 1); + EXPECT_EQ(intparam, 12); + + // string argument + argv = {"prog", "strparam=foo", "bar" }; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 1); + EXPECT_STREQ(strparam, "foo"); + + // empty string argument + argv = {"prog", "strparam=", "bar" }; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 1); + EXPECT_STREQ(strparam, ""); + + // Bad parameter + argv = {"prog", "fooparam=123"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 0); +} + +TEST(ConfigArgs, singleDash) +{ + int ret; + std::vector<const char*> argv; + + boolparam.setParam(true); + intparam.setParam(1); + strparam.setParam("test"); + + // int argument + argv = {"prog", "-intparam", "12", "34"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 2); + EXPECT_EQ(intparam, 12); + + // int argument with equals + argv = {"prog", "-intparam=12", "34"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 1); + EXPECT_EQ(intparam, 12); + + // string argument + argv = {"prog", "-strparam", "foo", "bar" }; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 2); + EXPECT_STREQ(strparam, "foo"); + + // string argument with equals + argv = {"prog", "-strparam=foo", "bar" }; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 1); + EXPECT_STREQ(strparam, "foo"); + + // empty string argument with equals + argv = {"prog", "-strparam=", "bar" }; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 1); + EXPECT_STREQ(strparam, ""); + + // Missing argument + intparam.setParam(1); + argv = {"prog", "-intparam"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 0); + EXPECT_EQ(intparam, 1); + + // Bad parameter + argv = {"prog", "-fooparam", "123"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 0); + + // Bad parameter with equals + argv = {"prog", "-fooparam=123"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 0); +} + +TEST(ConfigArgs, doubleDash) +{ + int ret; + std::vector<const char*> argv; + + boolparam.setParam(true); + intparam.setParam(1); + strparam.setParam("test"); + + // int argument + argv = {"prog", "--intparam", "12", "34"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 2); + EXPECT_EQ(intparam, 12); + + // int argument with equals + argv = {"prog", "--intparam=12", "34"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 1); + EXPECT_EQ(intparam, 12); + + // string argument + argv = {"prog", "--strparam", "foo", "bar" }; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 2); + EXPECT_STREQ(strparam, "foo"); + + // string argument with equals + argv = {"prog", "--strparam=foo", "bar" }; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 1); + EXPECT_STREQ(strparam, "foo"); + + // empty string argument with equals + argv = {"prog", "--strparam=", "bar" }; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 1); + EXPECT_STREQ(strparam, ""); + + // Missing argument + intparam.setParam(1); + argv = {"prog", "--intparam"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 0); + EXPECT_EQ(intparam, 1); + + // Bad parameter + argv = {"prog", "--fooparam", "123"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 0); + + // Bad parameter with equals + argv = {"prog", "--fooparam=123"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 0); +} + +TEST(ConfigArgs, bool) +{ + int ret; + std::vector<const char*> argv; + + // solo bool (single) + boolparam.setParam(false); + argv = {"prog", "-boolparam"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 1); + EXPECT_EQ(boolparam, true); + + // solo bool (double) + boolparam.setParam(false); + argv = {"prog", "--boolparam"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 1); + EXPECT_EQ(boolparam, true); + + // bool argument (single) + boolparam.setParam(true); + argv = {"prog", "-boolparam", "off", "on"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 2); + EXPECT_EQ(boolparam, false); + + // bool argument (double) + boolparam.setParam(true); + argv = {"prog", "--boolparam", "off", "on"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 2); + EXPECT_EQ(boolparam, false); + + // bool argument equals (single) + boolparam.setParam(true); + argv = {"prog", "-boolparam=off", "on"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 1); + EXPECT_EQ(boolparam, false); + + // bool argument equals (double) + boolparam.setParam(true); + argv = {"prog", "--boolparam=off", "on"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 1); + EXPECT_EQ(boolparam, false); + + // empty bool argument equals (single) + boolparam.setParam(true); + argv = {"prog", "-boolparam=", "on"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 1); + EXPECT_EQ(boolparam, true); + + // empty bool argument equals (double) + boolparam.setParam(true); + argv = {"prog", "--boolparam=", "on"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 1); + EXPECT_EQ(boolparam, true); + + // bool bad argument (single) + boolparam.setParam(false); + argv = {"prog", "-boolparam", "foo", "off"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 1); + EXPECT_EQ(boolparam, true); + + // bool bad argument (double) + boolparam.setParam(false); + argv = {"prog", "--boolparam", "foo", "off"}; + ret = core::Configuration::handleParamArg(argv.size(), + (char**)argv.data(), 1); + EXPECT_EQ(ret, 1); + EXPECT_EQ(boolparam, true); +} + +int main(int argc, char** argv) +{ + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/tests/unit/conv.cxx b/tests/unit/conv.cxx index 2f15cb55..e4959299 100644 --- a/tests/unit/conv.cxx +++ b/tests/unit/conv.cxx @@ -1,4 +1,4 @@ -/* Copyright 2013-2014 Pierre Ossman <ossman@cendio.se> for Cendio AB +/* Copyright 2013-2025 Pierre Ossman <ossman@cendio.se> for Cendio AB * * This is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -20,10 +20,12 @@ #include <config.h> #endif -#include <stdio.h> -#include <stdlib.h> #include <string.h> +#include <list> + +#include <gtest/gtest.h> + #include <rfb/PixelFormat.h> static const uint8_t pixelRed = 0xf1; @@ -61,7 +63,7 @@ void makePixel(const rfb::PixelFormat &pf, pf.bufferFromPixel(buffer, p); } -bool verifyPixel(const rfb::PixelFormat &dstpf, +void verifyPixel(const rfb::PixelFormat &dstpf, const rfb::PixelFormat &srcpf, const uint8_t *buffer) { @@ -89,14 +91,23 @@ bool verifyPixel(const rfb::PixelFormat &dstpf, ge = (1 << (8 - min(dstpf.greenBits, srcpf.greenBits))) - 1; be = (1 << (8 - min(dstpf.blueBits, srcpf.blueBits))) - 1; - if (abs(r - pixelRed) > re) - return false; - if (abs(g - pixelGreen) > ge) - return false; - if (abs(b - pixelBlue) > be) - return false; + EXPECT_NEAR(r, pixelRed, re); + EXPECT_NEAR(g, pixelGreen, ge); + EXPECT_NEAR(b, pixelBlue, be); +} - return true; +} + +typedef std::pair<rfb::PixelFormat, rfb::PixelFormat> TestPair; +typedef testing::TestWithParam<TestPair> Conv; + +namespace rfb { + +static std::ostream& operator<<(std::ostream& os, const PixelFormat& pf) +{ + char b[256]; + pf.print(b, sizeof(b)); + return os << b; } } @@ -104,12 +115,14 @@ bool verifyPixel(const rfb::PixelFormat &dstpf, using rfb::makePixel; using rfb::verifyPixel; -static bool testPixel(const rfb::PixelFormat &dstpf, - const rfb::PixelFormat &srcpf) +TEST_P(Conv, pixelFromPixel) { rfb::Pixel p; uint8_t buffer[4]; + const rfb::PixelFormat &srcpf = GetParam().first; + const rfb::PixelFormat &dstpf = GetParam().second; + makePixel(srcpf, buffer); p = srcpf.pixelFromBuffer(buffer); @@ -117,18 +130,17 @@ static bool testPixel(const rfb::PixelFormat &dstpf, memset(buffer, 0, sizeof(buffer)); dstpf.bufferFromPixel(buffer, p); - if (!verifyPixel(dstpf, srcpf, buffer)) - return false; - - return true; + verifyPixel(dstpf, srcpf, buffer); } -static bool testBuffer(const rfb::PixelFormat &dstpf, - const rfb::PixelFormat &srcpf) +TEST_P(Conv, bufferFromBuffer) { int i, x, y, unaligned; uint8_t bufIn[fbMalloc], bufOut[fbMalloc]; + const rfb::PixelFormat &srcpf = GetParam().first; + const rfb::PixelFormat &dstpf = GetParam().second; + // Once aligned, and once unaligned for (unaligned = 0;unaligned < 2;unaligned++) { for (i = 0;i < fbArea;i++) @@ -139,8 +151,9 @@ static bool testBuffer(const rfb::PixelFormat &dstpf, bufIn + unaligned, fbArea); for (i = 0;i < fbArea;i++) { - if (!verifyPixel(dstpf, srcpf, bufOut + unaligned + i*dstpf.bpp/8)) - return false; + verifyPixel(dstpf, srcpf, bufOut + unaligned + i*dstpf.bpp/8); + if (testing::Test::HasFailure()) + return; } memset(bufIn, 0, sizeof(bufIn)); @@ -155,29 +168,29 @@ static bool testBuffer(const rfb::PixelFormat &dstpf, for (y = 0;y < fbHeight;y++) { for (x = 0;x < fbWidth;x++) { + const uint8_t* pixel; + pixel = bufOut + unaligned + (x + y*fbWidth)*dstpf.bpp/8; if (x < fbWidth/2) { - if (!verifyPixel(dstpf, srcpf, - bufOut + unaligned + (x + y*fbWidth)*dstpf.bpp/8)) - return false; + verifyPixel(dstpf, srcpf, pixel); } else { const uint8_t zero[4] = { 0, 0, 0, 0 }; - if (memcmp(bufOut + unaligned + (x + y*fbWidth)*dstpf.bpp/8, zero, - dstpf.bpp/8) != 0) - return false; + EXPECT_EQ(memcmp(pixel, zero, dstpf.bpp/8), 0); } + if (testing::Test::HasFailure()) + return; } } } - - return true; } -static bool testRGB(const rfb::PixelFormat &dstpf, - const rfb::PixelFormat &srcpf) +TEST_P(Conv, bufferToFromRGB) { int i, x, y, unaligned; uint8_t bufIn[fbMalloc], bufRGB[fbMalloc], bufOut[fbMalloc]; + const rfb::PixelFormat &srcpf = GetParam().first; + const rfb::PixelFormat &dstpf = GetParam().second; + // Once aligned, and once unaligned for (unaligned = 0;unaligned < 2;unaligned++) { for (i = 0;i < fbArea;i++) @@ -190,8 +203,9 @@ static bool testRGB(const rfb::PixelFormat &dstpf, dstpf.bufferFromRGB(bufOut + unaligned, bufRGB + unaligned, fbArea); for (i = 0;i < fbArea;i++) { - if (!verifyPixel(dstpf, srcpf, bufOut + unaligned + i*dstpf.bpp/8)) - return false; + verifyPixel(dstpf, srcpf, bufOut + unaligned + i*dstpf.bpp/8); + if (testing::Test::HasFailure()) + return; } memset(bufIn, 0, sizeof(bufIn)); @@ -210,31 +224,31 @@ static bool testRGB(const rfb::PixelFormat &dstpf, for (y = 0;y < fbHeight;y++) { for (x = 0;x < fbWidth;x++) { + const uint8_t* pixel; + pixel = bufOut + unaligned + (x + y*fbWidth)*dstpf.bpp/8; if (x < fbWidth/2) { - if (!verifyPixel(dstpf, srcpf, - bufOut + unaligned + (x + y*fbWidth)*dstpf.bpp/8)) - return false; + verifyPixel(dstpf, srcpf, pixel); } else { const uint8_t zero[4] = { 0, 0, 0, 0 }; - if (memcmp(bufOut + unaligned + (x + y*fbWidth)*dstpf.bpp/8, zero, - dstpf.bpp/8) != 0) - return false; + EXPECT_EQ(memcmp(pixel, zero, dstpf.bpp/8), 0); } + if (testing::Test::HasFailure()) + return; } } } - - return true; } -static bool testPixelRGB(const rfb::PixelFormat &dstpf, - const rfb::PixelFormat &srcpf) +TEST_P(Conv, pixelToFromRGB) { rfb::Pixel p; uint16_t r16, g16, b16; uint8_t r8, g8, b8; uint8_t buffer[4]; + const rfb::PixelFormat &srcpf = GetParam().first; + const rfb::PixelFormat &dstpf = GetParam().second; + makePixel(srcpf, buffer); p = srcpf.pixelFromBuffer(buffer); @@ -243,8 +257,7 @@ static bool testPixelRGB(const rfb::PixelFormat &dstpf, memset(buffer, 0, sizeof(buffer)); dstpf.bufferFromPixel(buffer, p); - if (!verifyPixel(dstpf, srcpf, buffer)) - return false; + verifyPixel(dstpf, srcpf, buffer); makePixel(srcpf, buffer); @@ -254,112 +267,84 @@ static bool testPixelRGB(const rfb::PixelFormat &dstpf, memset(buffer, 0, sizeof(buffer)); dstpf.bufferFromPixel(buffer, p); - if (!verifyPixel(dstpf, srcpf, buffer)) - return false; - - return true; -} - -struct TestEntry tests[] = { - {"Pixel from pixel", testPixel}, - {"Buffer from buffer", testBuffer}, - {"Buffer to/from RGB", testRGB}, - {"Pixel to/from RGB", testPixelRGB}, -}; - -static void doTests(const rfb::PixelFormat &dstpf, - const rfb::PixelFormat &srcpf) -{ - size_t i; - char dstb[256], srcb[256]; - - dstpf.print(dstb, sizeof(dstb)); - srcpf.print(srcb, sizeof(srcb)); - - printf("\n"); - printf("%s to %s\n", srcb, dstb); - printf("\n"); - - for (i = 0;i < sizeof(tests)/sizeof(tests[0]);i++) { - printf(" %s: ", tests[i].label); - fflush(stdout); - if (tests[i].fn(dstpf, srcpf)) - printf("OK"); - else - printf("FAILED"); - printf("\n"); - } + verifyPixel(dstpf, srcpf, buffer); } -int main(int /*argc*/, char** /*argv*/) +static std::list<TestPair> paramGenerator() { + std::list<TestPair> params; rfb::PixelFormat dstpf, srcpf; - printf("Pixel Conversion Correctness Test\n"); - /* rgb888 targets */ dstpf.parse("rgb888"); srcpf.parse("rgb888"); - doTests(dstpf, srcpf); + params.push_back(std::make_pair(srcpf, dstpf)); srcpf.parse("bgr888"); - doTests(dstpf, srcpf); + params.push_back(std::make_pair(srcpf, dstpf)); srcpf.parse("rgb565"); - doTests(dstpf, srcpf); + params.push_back(std::make_pair(srcpf, dstpf)); srcpf.parse("rgb232"); - doTests(dstpf, srcpf); + params.push_back(std::make_pair(srcpf, dstpf)); /* rgb565 targets */ dstpf.parse("rgb565"); srcpf.parse("rgb888"); - doTests(dstpf, srcpf); + params.push_back(std::make_pair(srcpf, dstpf)); srcpf.parse("bgr565"); - doTests(dstpf, srcpf); + params.push_back(std::make_pair(srcpf, dstpf)); srcpf.parse("rgb232"); - doTests(dstpf, srcpf); + params.push_back(std::make_pair(srcpf, dstpf)); /* rgb232 targets */ dstpf.parse("rgb232"); srcpf.parse("rgb888"); - doTests(dstpf, srcpf); + params.push_back(std::make_pair(srcpf, dstpf)); srcpf.parse("rgb565"); - doTests(dstpf, srcpf); + params.push_back(std::make_pair(srcpf, dstpf)); srcpf.parse("bgr232"); - doTests(dstpf, srcpf); + params.push_back(std::make_pair(srcpf, dstpf)); /* endian conversion (both ways) */ dstpf = rfb::PixelFormat(32, 24, false, true, 255, 255, 255, 0, 8, 16); srcpf = rfb::PixelFormat(32, 24, true, true, 255, 255, 255, 0, 8, 16); - doTests(dstpf, srcpf); - - doTests(srcpf, dstpf); + params.push_back(std::make_pair(srcpf, dstpf)); + params.push_back(std::make_pair(dstpf, srcpf)); dstpf = rfb::PixelFormat(16, 16, false, true, 31, 63, 31, 0, 5, 11); srcpf = rfb::PixelFormat(16, 16, true, true, 31, 63, 31, 0, 5, 11); - doTests(dstpf, srcpf); - - doTests(srcpf, dstpf); + params.push_back(std::make_pair(srcpf, dstpf)); + params.push_back(std::make_pair(dstpf, srcpf)); // Pesky case that is very asymetrical dstpf = rfb::PixelFormat(32, 24, false, true, 255, 255, 255, 0, 8, 16); srcpf = rfb::PixelFormat(32, 24, true, true, 255, 255, 255, 0, 24, 8); - doTests(dstpf, srcpf); + params.push_back(std::make_pair(srcpf, dstpf)); + params.push_back(std::make_pair(dstpf, srcpf)); - doTests(srcpf, dstpf); + return params; +} + +INSTANTIATE_TEST_SUITE_P(, Conv, testing::ValuesIn(paramGenerator())); + +int main(int argc, char** argv) +{ + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } diff --git a/tests/unit/convertlf.cxx b/tests/unit/convertlf.cxx index 1645532a..3392725a 100644 --- a/tests/unit/convertlf.cxx +++ b/tests/unit/convertlf.cxx @@ -1,4 +1,4 @@ -/* Copyright 2019 Pierre Ossman <ossman@cendio.se> for Cendio AB +/* Copyright 2019-2025 Pierre Ossman <ossman@cendio.se> for Cendio AB * * This is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -20,105 +20,56 @@ #include <config.h> #endif -#include <stdio.h> +#include <gtest/gtest.h> -#include <rfb/util.h> +#include <core/string.h> -static const char* escape(const char* input) +TEST(ConvertLF, convertLF) { - static char output[4096]; - - const char* in; - char* out; - - in = input; - out = output; - do { - if (*in == '\r') { - *out++ = '\\'; - *out++ = 'r'; - } else if (*in == '\n') { - *out++ = '\\'; - *out++ = 'n'; - } else { - *out++ = *in; - } - } while (*in++ != '\0'); - - return output; -} - -static void testLF(const char* input, const char* expected) -{ - std::string output; - - printf("convertLF(\"%s\"): ", escape(input)); - - output = rfb::convertLF(input); - - if (output != expected) - printf("FAILED: got \"%s\"", escape(output.c_str())); - else - printf("OK"); - printf("\n"); - fflush(stdout); + EXPECT_EQ(core::convertLF(""), ""); + EXPECT_EQ(core::convertLF("no EOL"), "no EOL"); + + EXPECT_EQ(core::convertLF("\n"), "\n"); + EXPECT_EQ(core::convertLF("already correct\n"), "already correct\n"); + EXPECT_EQ(core::convertLF("multiple\nlines\n"), "multiple\nlines\n"); + EXPECT_EQ(core::convertLF("empty lines\n\n"), "empty lines\n\n"); + EXPECT_EQ(core::convertLF("\ninitial line"), "\ninitial line"); + + EXPECT_EQ(core::convertLF("\r\n"), "\n"); + EXPECT_EQ(core::convertLF("one line\r\n"), "one line\n"); + EXPECT_EQ(core::convertLF("multiple\r\nlines\r\n"), "multiple\nlines\n"); + EXPECT_EQ(core::convertLF("empty lines\r\n\r\n"), "empty lines\n\n"); + EXPECT_EQ(core::convertLF("\r\ninitial line"), "\ninitial line"); + EXPECT_EQ(core::convertLF("mixed\r\nlines\n"), "mixed\nlines\n"); + + EXPECT_EQ(core::convertLF("cropped\r"), "cropped\n"); + EXPECT_EQ(core::convertLF("old\rmac\rformat"), "old\nmac\nformat"); } -static void testCRLF(const char* input, const char* expected) +TEST(ConvertLF, convertCRLF) { - std::string output; - - printf("convertCRLF(\"%s\"): ", escape(input)); - - output = rfb::convertCRLF(input); - - if (output != expected) - printf("FAILED: got \"%s\"", escape(output.c_str())); - else - printf("OK"); - printf("\n"); - fflush(stdout); + EXPECT_EQ(core::convertCRLF(""), ""); + EXPECT_EQ(core::convertCRLF("no EOL"), "no EOL"); + + EXPECT_EQ(core::convertCRLF("\r\n"), "\r\n"); + EXPECT_EQ(core::convertCRLF("already correct\r\n"), "already correct\r\n"); + EXPECT_EQ(core::convertCRLF("multiple\r\nlines\r\n"), "multiple\r\nlines\r\n"); + EXPECT_EQ(core::convertCRLF("empty lines\r\n\r\n"), "empty lines\r\n\r\n"); + EXPECT_EQ(core::convertCRLF("\r\ninitial line"), "\r\ninitial line"); + + EXPECT_EQ(core::convertCRLF("\n"), "\r\n"); + EXPECT_EQ(core::convertCRLF("one line\n"), "one line\r\n"); + EXPECT_EQ(core::convertCRLF("multiple\nlines\n"), "multiple\r\nlines\r\n"); + EXPECT_EQ(core::convertCRLF("empty lines\n\n"), "empty lines\r\n\r\n"); + EXPECT_EQ(core::convertCRLF("\ninitial line"), "\r\ninitial line"); + EXPECT_EQ(core::convertCRLF("mixed\r\nlines\n"), "mixed\r\nlines\r\n"); + + EXPECT_EQ(core::convertCRLF("cropped\r"), "cropped\r\n"); + EXPECT_EQ(core::convertCRLF("old\rmac\rformat"), "old\r\nmac\r\nformat"); } -int main(int /*argc*/, char** /*argv*/) +int main(int argc, char** argv) { - testLF("", ""); - testLF("no EOL", "no EOL"); - - testLF("\n", "\n"); - testLF("already correct\n", "already correct\n"); - testLF("multiple\nlines\n", "multiple\nlines\n"); - testLF("empty lines\n\n", "empty lines\n\n"); - testLF("\ninitial line", "\ninitial line"); - - testLF("\r\n", "\n"); - testLF("one line\r\n", "one line\n"); - testLF("multiple\r\nlines\r\n", "multiple\nlines\n"); - testLF("empty lines\r\n\r\n", "empty lines\n\n"); - testLF("\r\ninitial line", "\ninitial line"); - testLF("mixed\r\nlines\n", "mixed\nlines\n"); - - testLF("cropped\r", "cropped\n"); - testLF("old\rmac\rformat", "old\nmac\nformat"); - - testCRLF("", ""); - testCRLF("no EOL", "no EOL"); - - testCRLF("\r\n", "\r\n"); - testCRLF("already correct\r\n", "already correct\r\n"); - testCRLF("multiple\r\nlines\r\n", "multiple\r\nlines\r\n"); - testCRLF("empty lines\r\n\r\n", "empty lines\r\n\r\n"); - testCRLF("\r\ninitial line", "\r\ninitial line"); - - testCRLF("\n", "\r\n"); - testCRLF("one line\n", "one line\r\n"); - testCRLF("multiple\nlines\n", "multiple\r\nlines\r\n"); - testCRLF("empty lines\n\n", "empty lines\r\n\r\n"); - testCRLF("\ninitial line", "\r\ninitial line"); - testCRLF("mixed\r\nlines\n", "mixed\r\nlines\r\n"); - - testCRLF("cropped\r", "cropped\r\n"); - testCRLF("old\rmac\rformat", "old\r\nmac\r\nformat"); - - return 0; + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } diff --git a/tests/unit/emulatemb.cxx b/tests/unit/emulatemb.cxx index 6db8ea38..d59ce509 100644 --- a/tests/unit/emulatemb.cxx +++ b/tests/unit/emulatemb.cxx @@ -1,4 +1,5 @@ /* Copyright 2020 Alex Tanskanen <aleta@cendio.se> for Cendio AB + * Copyright 2025 Pierre Ossman <ossman@cendio.se> for Cendio AB * * This is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -20,12 +21,15 @@ #include <config.h> #endif -#include <stdio.h> -#include <vector> #include <unistd.h> -#include <rfb/Rect.h> -#include <rfb/Configuration.h> +#include <vector> + +#include <gtest/gtest.h> + +#include <core/Rect.h> +#include <core/Configuration.h> + #include "EmulateMB.h" // The button masks for the mouse buttons @@ -37,19 +41,19 @@ static const int right = 0x04; static const int both = 0x05; static const int middleAndRight = 0x06; -rfb::BoolParameter emulateMiddleButton("dummy_name", "dummy_desc", true); +core::BoolParameter emulateMiddleButton("dummy_name", "dummy_desc", true); class TestClass : public EmulateMB { public: - void sendPointerEvent(const rfb::Point& pos, uint16_t buttonMask) override; + void sendPointerEvent(const core::Point& pos, uint16_t buttonMask) override; - struct PointerEventParams {rfb::Point pos; uint16_t mask; }; + struct PointerEventParams {core::Point pos; uint16_t mask; }; std::vector<PointerEventParams> results; }; -void TestClass::sendPointerEvent(const rfb::Point& pos, uint16_t buttonMask) +void TestClass::sendPointerEvent(const core::Point& pos, uint16_t buttonMask) { PointerEventParams params; params.pos = pos; @@ -57,435 +61,347 @@ void TestClass::sendPointerEvent(const rfb::Point& pos, uint16_t buttonMask) results.push_back(params); } -#define ASSERT_EQ(expr, val) if ((expr) != (val)) { \ - printf("FAILED on line %d (%s equals %d, expected %d)\n", __LINE__, #expr, (int)(expr), (int)(val)); \ - return; \ -} - -void testDisabledOption() +TEST(EmulateMB, disabledOption) { TestClass test; - printf("%s: ", __func__); - emulateMiddleButton.setParam(false); - test.filterPointerEvent(rfb::Point(0, 10), left); + test.filterPointerEvent({0, 10}, left); ASSERT_EQ(test.results.size(), 1); - ASSERT_EQ(test.results[0].pos.x, 0); - ASSERT_EQ(test.results[0].pos.y, 10); - ASSERT_EQ(test.results[0].mask, left); - - printf("OK\n"); + EXPECT_EQ(test.results[0].pos.x, 0); + EXPECT_EQ(test.results[0].pos.y, 10); + EXPECT_EQ(test.results[0].mask, left); } -void testLeftClick() +TEST(EmulateMB, leftClick) { TestClass test; - printf("%s: ", __func__); - emulateMiddleButton.setParam(true); - test.filterPointerEvent(rfb::Point(0, 0), left); - test.filterPointerEvent(rfb::Point(0, 0), empty); + test.filterPointerEvent({0, 0}, left); + test.filterPointerEvent({0, 0}, empty); ASSERT_EQ(test.results.size(), 3); - ASSERT_EQ(test.results[0].pos.x, 0); - ASSERT_EQ(test.results[0].pos.y, 0); - ASSERT_EQ(test.results[0].mask, empty); - - ASSERT_EQ(test.results[1].pos.x, 0); - ASSERT_EQ(test.results[1].pos.y, 0); - ASSERT_EQ(test.results[1].mask, left); + EXPECT_EQ(test.results[0].pos.x, 0); + EXPECT_EQ(test.results[0].pos.y, 0); + EXPECT_EQ(test.results[0].mask, empty); - ASSERT_EQ(test.results[2].pos.x, 0); - ASSERT_EQ(test.results[2].pos.y, 0); - ASSERT_EQ(test.results[2].mask, empty); + EXPECT_EQ(test.results[1].pos.x, 0); + EXPECT_EQ(test.results[1].pos.y, 0); + EXPECT_EQ(test.results[1].mask, left); - printf("OK\n"); + EXPECT_EQ(test.results[2].pos.x, 0); + EXPECT_EQ(test.results[2].pos.y, 0); + EXPECT_EQ(test.results[2].mask, empty); } -void testNormalLeftPress() +TEST(EmulateMB, normalLeftPress) { TestClass test; - printf("%s: ", __func__); - emulateMiddleButton.setParam(true); - test.filterPointerEvent(rfb::Point(10, 20), left); + test.filterPointerEvent({10, 20}, left); usleep(100000); // 0.1s - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); ASSERT_EQ(test.results.size(), 2); - ASSERT_EQ(test.results[0].pos.x, 10); - ASSERT_EQ(test.results[0].pos.y, 20); - ASSERT_EQ(test.results[0].mask, empty); + EXPECT_EQ(test.results[0].pos.x, 10); + EXPECT_EQ(test.results[0].pos.y, 20); + EXPECT_EQ(test.results[0].mask, empty); - ASSERT_EQ(test.results[1].pos.x, 10); - ASSERT_EQ(test.results[1].pos.y, 20); - ASSERT_EQ(test.results[1].mask, left); - - printf("OK\n"); + EXPECT_EQ(test.results[1].pos.x, 10); + EXPECT_EQ(test.results[1].pos.y, 20); + EXPECT_EQ(test.results[1].mask, left); } -void testNormalMiddlePress() +TEST(EmulateMB, normalMiddlePress) { TestClass test; - printf("%s: ", __func__); - emulateMiddleButton.setParam(true); - test.filterPointerEvent(rfb::Point(0, 0), middle); + test.filterPointerEvent({0, 0}, middle); ASSERT_EQ(test.results.size(), 1); - ASSERT_EQ(test.results[0].pos.x, 0); - ASSERT_EQ(test.results[0].pos.y, 0); - ASSERT_EQ(test.results[0].mask, middle); - - printf("OK\n"); + EXPECT_EQ(test.results[0].pos.x, 0); + EXPECT_EQ(test.results[0].pos.y, 0); + EXPECT_EQ(test.results[0].mask, middle); } -void testNormalRightPress() +TEST(EmulateMB, normalRightPress) { TestClass test; - printf("%s: ", __func__); - emulateMiddleButton.setParam(true); - test.filterPointerEvent(rfb::Point(0, 0), right); + test.filterPointerEvent({0, 0}, right); usleep(100000); // 0.1s - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); ASSERT_EQ(test.results.size(), 2); - ASSERT_EQ(test.results[0].pos.x, 0); - ASSERT_EQ(test.results[0].pos.y, 0); - ASSERT_EQ(test.results[0].mask, empty); - - ASSERT_EQ(test.results[1].pos.x, 0); - ASSERT_EQ(test.results[1].pos.y, 0); - ASSERT_EQ(test.results[1].mask, right); + EXPECT_EQ(test.results[0].pos.x, 0); + EXPECT_EQ(test.results[0].pos.y, 0); + EXPECT_EQ(test.results[0].mask, empty); - printf("OK\n"); + EXPECT_EQ(test.results[1].pos.x, 0); + EXPECT_EQ(test.results[1].pos.y, 0); + EXPECT_EQ(test.results[1].mask, right); } -void testEmulateMiddleMouseButton() +TEST(EmulateMB, emulateMiddleMouseButton) { TestClass test; - printf("%s: ", __func__); - emulateMiddleButton.setParam(true); - test.filterPointerEvent(rfb::Point(20, 30), right); - test.filterPointerEvent(rfb::Point(20, 30), both); + test.filterPointerEvent({20, 30}, right); + test.filterPointerEvent({20, 30}, both); ASSERT_EQ(test.results.size(), 2); - ASSERT_EQ(test.results[0].pos.x, 20); - ASSERT_EQ(test.results[0].pos.y, 30); - ASSERT_EQ(test.results[0].mask, empty); + EXPECT_EQ(test.results[0].pos.x, 20); + EXPECT_EQ(test.results[0].pos.y, 30); + EXPECT_EQ(test.results[0].mask, empty); - ASSERT_EQ(test.results[1].pos.x, 20); - ASSERT_EQ(test.results[1].pos.y, 30); - ASSERT_EQ(test.results[1].mask, middle); - - printf("OK\n"); + EXPECT_EQ(test.results[1].pos.x, 20); + EXPECT_EQ(test.results[1].pos.y, 30); + EXPECT_EQ(test.results[1].mask, middle); } -void testLeftReleaseAfterEmulate() +TEST(EmulateMB, leftReleaseAfterEmulate) { TestClass test; - printf("%s: ", __func__); - emulateMiddleButton.setParam(true); - test.filterPointerEvent(rfb::Point(20, 30), left); - test.filterPointerEvent(rfb::Point(20, 30), both); - test.filterPointerEvent(rfb::Point(20, 30), right); // left released + test.filterPointerEvent({20, 30}, left); + test.filterPointerEvent({20, 30}, both); + test.filterPointerEvent({20, 30}, right); // left released ASSERT_EQ(test.results.size(), 3); - ASSERT_EQ(test.results[0].pos.x, 20); - ASSERT_EQ(test.results[0].pos.y, 30); - ASSERT_EQ(test.results[0].mask, empty); - - ASSERT_EQ(test.results[1].pos.x, 20); - ASSERT_EQ(test.results[1].pos.y, 30); - ASSERT_EQ(test.results[1].mask, middle); + EXPECT_EQ(test.results[0].pos.x, 20); + EXPECT_EQ(test.results[0].pos.y, 30); + EXPECT_EQ(test.results[0].mask, empty); - ASSERT_EQ(test.results[2].pos.x, 20); - ASSERT_EQ(test.results[2].pos.y, 30); - ASSERT_EQ(test.results[2].mask, middle); + EXPECT_EQ(test.results[1].pos.x, 20); + EXPECT_EQ(test.results[1].pos.y, 30); + EXPECT_EQ(test.results[1].mask, middle); - printf("OK\n"); + EXPECT_EQ(test.results[2].pos.x, 20); + EXPECT_EQ(test.results[2].pos.y, 30); + EXPECT_EQ(test.results[2].mask, middle); } -void testRightReleaseAfterEmulate() +TEST(EmulateMB, rightReleaseAfterEmulate) { TestClass test; - printf("%s: ", __func__); - emulateMiddleButton.setParam(true); - test.filterPointerEvent(rfb::Point(20, 30), right); - test.filterPointerEvent(rfb::Point(20, 30), both); - test.filterPointerEvent(rfb::Point(20, 30), left); // right released + test.filterPointerEvent({20, 30}, right); + test.filterPointerEvent({20, 30}, both); + test.filterPointerEvent({20, 30}, left); // right released ASSERT_EQ(test.results.size(), 3); - ASSERT_EQ(test.results[0].pos.x, 20); - ASSERT_EQ(test.results[0].pos.y, 30); - ASSERT_EQ(test.results[0].mask, empty); - - ASSERT_EQ(test.results[1].pos.x, 20); - ASSERT_EQ(test.results[1].pos.y, 30); - ASSERT_EQ(test.results[1].mask, middle); + EXPECT_EQ(test.results[0].pos.x, 20); + EXPECT_EQ(test.results[0].pos.y, 30); + EXPECT_EQ(test.results[0].mask, empty); - ASSERT_EQ(test.results[2].pos.x, 20); - ASSERT_EQ(test.results[2].pos.y, 30); - ASSERT_EQ(test.results[2].mask, middle); + EXPECT_EQ(test.results[1].pos.x, 20); + EXPECT_EQ(test.results[1].pos.y, 30); + EXPECT_EQ(test.results[1].mask, middle); - printf("OK\n"); + EXPECT_EQ(test.results[2].pos.x, 20); + EXPECT_EQ(test.results[2].pos.y, 30); + EXPECT_EQ(test.results[2].mask, middle); } -void testLeftRepressAfterEmulate() +TEST(EmulateMB, leftRepressAfterEmulate) { TestClass test; - printf("%s: ", __func__); - emulateMiddleButton.setParam(true); - test.filterPointerEvent(rfb::Point(20, 30), left); - test.filterPointerEvent(rfb::Point(20, 30), both); - test.filterPointerEvent(rfb::Point(20, 30), right); // left released - test.filterPointerEvent(rfb::Point(20, 30), both); + test.filterPointerEvent({20, 30}, left); + test.filterPointerEvent({20, 30}, both); + test.filterPointerEvent({20, 30}, right); // left released + test.filterPointerEvent({20, 30}, both); ASSERT_EQ(test.results.size(), 4); - ASSERT_EQ(test.results[0].pos.x, 20); - ASSERT_EQ(test.results[0].pos.y, 30); - ASSERT_EQ(test.results[0].mask, empty); - - ASSERT_EQ(test.results[1].pos.x, 20); - ASSERT_EQ(test.results[1].pos.y, 30); - ASSERT_EQ(test.results[1].mask, middle); + EXPECT_EQ(test.results[0].pos.x, 20); + EXPECT_EQ(test.results[0].pos.y, 30); + EXPECT_EQ(test.results[0].mask, empty); - ASSERT_EQ(test.results[2].pos.x, 20); - ASSERT_EQ(test.results[2].pos.y, 30); - ASSERT_EQ(test.results[2].mask, middle); + EXPECT_EQ(test.results[1].pos.x, 20); + EXPECT_EQ(test.results[1].pos.y, 30); + EXPECT_EQ(test.results[1].mask, middle); - ASSERT_EQ(test.results[3].pos.x, 20); - ASSERT_EQ(test.results[3].pos.y, 30); - ASSERT_EQ(test.results[3].mask, middleAndLeft); + EXPECT_EQ(test.results[2].pos.x, 20); + EXPECT_EQ(test.results[2].pos.y, 30); + EXPECT_EQ(test.results[2].mask, middle); - printf("OK\n"); + EXPECT_EQ(test.results[3].pos.x, 20); + EXPECT_EQ(test.results[3].pos.y, 30); + EXPECT_EQ(test.results[3].mask, middleAndLeft); } -void testRightRepressAfterEmulate() +TEST(EmulateMB, rightRepressAfterEmulate) { TestClass test; - printf("%s: ", __func__); - emulateMiddleButton.setParam(true); - test.filterPointerEvent(rfb::Point(20, 30), right); - test.filterPointerEvent(rfb::Point(20, 30), both); - test.filterPointerEvent(rfb::Point(20, 30), left); // right released - test.filterPointerEvent(rfb::Point(20, 30), both); + test.filterPointerEvent({20, 30}, right); + test.filterPointerEvent({20, 30}, both); + test.filterPointerEvent({20, 30}, left); // right released + test.filterPointerEvent({20, 30}, both); ASSERT_EQ(test.results.size(), 4); - ASSERT_EQ(test.results[0].pos.x, 20); - ASSERT_EQ(test.results[0].pos.y, 30); - ASSERT_EQ(test.results[0].mask, empty); + EXPECT_EQ(test.results[0].pos.x, 20); + EXPECT_EQ(test.results[0].pos.y, 30); + EXPECT_EQ(test.results[0].mask, empty); - ASSERT_EQ(test.results[1].pos.x, 20); - ASSERT_EQ(test.results[1].pos.y, 30); - ASSERT_EQ(test.results[1].mask, middle); + EXPECT_EQ(test.results[1].pos.x, 20); + EXPECT_EQ(test.results[1].pos.y, 30); + EXPECT_EQ(test.results[1].mask, middle); - ASSERT_EQ(test.results[2].pos.x, 20); - ASSERT_EQ(test.results[2].pos.y, 30); - ASSERT_EQ(test.results[2].mask, middle); + EXPECT_EQ(test.results[2].pos.x, 20); + EXPECT_EQ(test.results[2].pos.y, 30); + EXPECT_EQ(test.results[2].mask, middle); - ASSERT_EQ(test.results[3].pos.x, 20); - ASSERT_EQ(test.results[3].pos.y, 30); - ASSERT_EQ(test.results[3].mask, middleAndRight); - - printf("OK\n"); + EXPECT_EQ(test.results[3].pos.x, 20); + EXPECT_EQ(test.results[3].pos.y, 30); + EXPECT_EQ(test.results[3].mask, middleAndRight); } -void testBothPressAfterLeftTimeout() +TEST(EmulateMB, bothPressAfterLeftTimeout) { TestClass test; - printf("%s: ", __func__); - emulateMiddleButton.setParam(true); - test.filterPointerEvent(rfb::Point(10, 20), left); + test.filterPointerEvent({10, 20}, left); usleep(100000); // 0.1s - rfb::Timer::checkTimeouts(); - test.filterPointerEvent(rfb::Point(10, 20), both); + core::Timer::checkTimeouts(); + test.filterPointerEvent({10, 20}, both); ASSERT_EQ(test.results.size(), 3); - ASSERT_EQ(test.results[0].pos.x, 10); - ASSERT_EQ(test.results[0].pos.y, 20); - ASSERT_EQ(test.results[0].mask, empty); - - ASSERT_EQ(test.results[1].pos.x, 10); - ASSERT_EQ(test.results[1].pos.y, 20); - ASSERT_EQ(test.results[1].mask, left); + EXPECT_EQ(test.results[0].pos.x, 10); + EXPECT_EQ(test.results[0].pos.y, 20); + EXPECT_EQ(test.results[0].mask, empty); - ASSERT_EQ(test.results[2].pos.x, 10); - ASSERT_EQ(test.results[2].pos.y, 20); - ASSERT_EQ(test.results[2].mask, both); + EXPECT_EQ(test.results[1].pos.x, 10); + EXPECT_EQ(test.results[1].pos.y, 20); + EXPECT_EQ(test.results[1].mask, left); - printf("OK\n"); + EXPECT_EQ(test.results[2].pos.x, 10); + EXPECT_EQ(test.results[2].pos.y, 20); + EXPECT_EQ(test.results[2].mask, both); } -void testBothPressAfterRightTimeout() +TEST(EmulateMB, bothPressAfterRightTimeout) { TestClass test; - printf("%s: ", __func__); - emulateMiddleButton.setParam(true); - test.filterPointerEvent(rfb::Point(10, 20), right); + test.filterPointerEvent({10, 20}, right); usleep(100000); // 0.1s - rfb::Timer::checkTimeouts(); - test.filterPointerEvent(rfb::Point(10, 20), both); + core::Timer::checkTimeouts(); + test.filterPointerEvent({10, 20}, both); ASSERT_EQ(test.results.size(), 3); - ASSERT_EQ(test.results[0].pos.x, 10); - ASSERT_EQ(test.results[0].pos.y, 20); - ASSERT_EQ(test.results[0].mask, empty); - - ASSERT_EQ(test.results[1].pos.x, 10); - ASSERT_EQ(test.results[1].pos.y, 20); - ASSERT_EQ(test.results[1].mask, right); + EXPECT_EQ(test.results[0].pos.x, 10); + EXPECT_EQ(test.results[0].pos.y, 20); + EXPECT_EQ(test.results[0].mask, empty); - ASSERT_EQ(test.results[2].pos.x, 10); - ASSERT_EQ(test.results[2].pos.y, 20); - ASSERT_EQ(test.results[2].mask, both); + EXPECT_EQ(test.results[1].pos.x, 10); + EXPECT_EQ(test.results[1].pos.y, 20); + EXPECT_EQ(test.results[1].mask, right); - printf("OK\n"); + EXPECT_EQ(test.results[2].pos.x, 10); + EXPECT_EQ(test.results[2].pos.y, 20); + EXPECT_EQ(test.results[2].mask, both); } -void testTimeoutAndDrag() +TEST(EmulateMB, timeoutAndDrag) { TestClass test; - printf("%s: ", __func__); - emulateMiddleButton.setParam(true); - test.filterPointerEvent(rfb::Point(0, 0), left); + test.filterPointerEvent({0, 0}, left); usleep(100000); //0.1s - rfb::Timer::checkTimeouts(); - test.filterPointerEvent(rfb::Point(10, 10), left); + core::Timer::checkTimeouts(); + test.filterPointerEvent({10, 10}, left); ASSERT_EQ(test.results.size(), 3); - ASSERT_EQ(test.results[0].pos.x, 0); - ASSERT_EQ(test.results[0].pos.y, 0); - ASSERT_EQ(test.results[0].mask, empty); + EXPECT_EQ(test.results[0].pos.x, 0); + EXPECT_EQ(test.results[0].pos.y, 0); + EXPECT_EQ(test.results[0].mask, empty); - ASSERT_EQ(test.results[1].pos.x, 0); - ASSERT_EQ(test.results[1].pos.y, 0); - ASSERT_EQ(test.results[1].mask, left); + EXPECT_EQ(test.results[1].pos.x, 0); + EXPECT_EQ(test.results[1].pos.y, 0); + EXPECT_EQ(test.results[1].mask, left); - ASSERT_EQ(test.results[2].pos.x, 10); - ASSERT_EQ(test.results[2].pos.y, 10); - ASSERT_EQ(test.results[2].mask, left); - - printf("OK\n"); + EXPECT_EQ(test.results[2].pos.x, 10); + EXPECT_EQ(test.results[2].pos.y, 10); + EXPECT_EQ(test.results[2].mask, left); } -void testDragAndTimeout() +TEST(EmulateMB, dragAndTimeout) { TestClass test; - printf("%s: ", __func__); - emulateMiddleButton.setParam(true); - test.filterPointerEvent(rfb::Point(10, 10), left); - test.filterPointerEvent(rfb::Point(30, 30), left); + test.filterPointerEvent({10, 10}, left); + test.filterPointerEvent({30, 30}, left); usleep(100000); //0.1s - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); ASSERT_EQ(test.results.size(), 3); - ASSERT_EQ(test.results[0].pos.x, 10); - ASSERT_EQ(test.results[0].pos.y, 10); - ASSERT_EQ(test.results[0].mask, empty); - - ASSERT_EQ(test.results[1].pos.x, 10); - ASSERT_EQ(test.results[1].pos.y, 10); - ASSERT_EQ(test.results[1].mask, left); + EXPECT_EQ(test.results[0].pos.x, 10); + EXPECT_EQ(test.results[0].pos.y, 10); + EXPECT_EQ(test.results[0].mask, empty); - ASSERT_EQ(test.results[2].pos.x, 30); - ASSERT_EQ(test.results[2].pos.y, 30); - ASSERT_EQ(test.results[2].mask, left); + EXPECT_EQ(test.results[1].pos.x, 10); + EXPECT_EQ(test.results[1].pos.y, 10); + EXPECT_EQ(test.results[1].mask, left); - printf("OK\n"); + EXPECT_EQ(test.results[2].pos.x, 30); + EXPECT_EQ(test.results[2].pos.y, 30); + EXPECT_EQ(test.results[2].mask, left); } -void testDragAndRelease() +TEST(EmulateMB, dragAndRelease) { TestClass test; - printf("%s: ", __func__); - emulateMiddleButton.setParam(true); - test.filterPointerEvent(rfb::Point(10, 10), left); - test.filterPointerEvent(rfb::Point(20, 20), empty); + test.filterPointerEvent({10, 10}, left); + test.filterPointerEvent({20, 20}, empty); ASSERT_EQ(test.results.size(), 3); - ASSERT_EQ(test.results[0].pos.x, 10); - ASSERT_EQ(test.results[0].pos.y, 10); - ASSERT_EQ(test.results[0].mask, empty); - - ASSERT_EQ(test.results[1].pos.x, 10); - ASSERT_EQ(test.results[1].pos.y, 10); - ASSERT_EQ(test.results[1].mask, left); + EXPECT_EQ(test.results[0].pos.x, 10); + EXPECT_EQ(test.results[0].pos.y, 10); + EXPECT_EQ(test.results[0].mask, empty); - ASSERT_EQ(test.results[2].pos.x, 20); - ASSERT_EQ(test.results[2].pos.y, 20); - ASSERT_EQ(test.results[2].mask, empty); + EXPECT_EQ(test.results[1].pos.x, 10); + EXPECT_EQ(test.results[1].pos.y, 10); + EXPECT_EQ(test.results[1].mask, left); - printf("OK\n"); + EXPECT_EQ(test.results[2].pos.x, 20); + EXPECT_EQ(test.results[2].pos.y, 20); + EXPECT_EQ(test.results[2].mask, empty); } -int main(int /*argc*/, char** /*argv*/) +int main(int argc, char** argv) { - testDisabledOption(); - - testLeftClick(); - - testNormalLeftPress(); - testNormalMiddlePress(); - testNormalRightPress(); - - testEmulateMiddleMouseButton(); - - testLeftReleaseAfterEmulate(); - testRightReleaseAfterEmulate(); - - testLeftRepressAfterEmulate(); - testRightRepressAfterEmulate(); - - testBothPressAfterLeftTimeout(); - testBothPressAfterRightTimeout(); - - testTimeoutAndDrag(); - - testDragAndTimeout(); - testDragAndRelease(); - - return 0; + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } diff --git a/tests/unit/gesturehandler.cxx b/tests/unit/gesturehandler.cxx index 73b8c62c..cf2e5b6b 100644 --- a/tests/unit/gesturehandler.cxx +++ b/tests/unit/gesturehandler.cxx @@ -1,4 +1,4 @@ -/* Copyright 2020 Pierre Ossman <ossman@cendio.se> for Cendio AB +/* Copyright 2020-2025 Pierre Ossman <ossman@cendio.se> for Cendio AB * * This is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -20,11 +20,12 @@ #include <config.h> #endif -#include <stdio.h> #include <unistd.h> #include <vector> +#include <gtest/gtest.h> + #include "../../vncviewer/GestureHandler.h" class TestClass : public GestureHandler @@ -41,18 +42,10 @@ void TestClass::handleGestureEvent(const GestureEvent& event) events.push_back(event); } -// FIXME: handle doubles -#define ASSERT_EQ(expr, val) if ((expr) != (val)) { \ - printf("FAILED on line %d (%s equals %d, expected %d)\n", __LINE__, #expr, (int)(expr), (int)(val)); \ - return; \ -} - -void testOneTapNormal() +TEST(GestureHandler, oneTapNormal) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); ASSERT_EQ(test.events.size(), 0); @@ -61,25 +54,21 @@ void testOneTapNormal() ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GestureOneTap); - ASSERT_EQ(test.events[0].eventX, 20.0); - ASSERT_EQ(test.events[0].eventY, 30.0); - - ASSERT_EQ(test.events[1].type, GestureEnd); - ASSERT_EQ(test.events[1].gesture, GestureOneTap); - ASSERT_EQ(test.events[1].eventX, 20.0); - ASSERT_EQ(test.events[1].eventY, 30.0); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GestureOneTap); + EXPECT_EQ(test.events[0].eventX, 20.0); + EXPECT_EQ(test.events[0].eventY, 30.0); - printf("OK\n"); + EXPECT_EQ(test.events[1].type, GestureEnd); + EXPECT_EQ(test.events[1].gesture, GestureOneTap); + EXPECT_EQ(test.events[1].eventX, 20.0); + EXPECT_EQ(test.events[1].eventY, 30.0); } -void testTwoTapNormal() +TEST(GestureHandler, twoTapNormal) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); test.handleTouchBegin(2, 30.0, 50.0); @@ -93,85 +82,69 @@ void testTwoTapNormal() ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GestureTwoTap); - ASSERT_EQ(test.events[0].eventX, 25.0); - ASSERT_EQ(test.events[0].eventY, 40.0); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GestureTwoTap); + EXPECT_EQ(test.events[0].eventX, 25.0); + EXPECT_EQ(test.events[0].eventY, 40.0); - ASSERT_EQ(test.events[1].type, GestureEnd); - ASSERT_EQ(test.events[1].gesture, GestureTwoTap); - ASSERT_EQ(test.events[1].eventX, 25.0); - ASSERT_EQ(test.events[1].eventY, 40.0); - - printf("OK\n"); + EXPECT_EQ(test.events[1].type, GestureEnd); + EXPECT_EQ(test.events[1].gesture, GestureTwoTap); + EXPECT_EQ(test.events[1].eventX, 25.0); + EXPECT_EQ(test.events[1].eventY, 40.0); } -void testTwoTapSlowBegin() +TEST(GestureHandler, twoTapSlowBegin) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); usleep(500000); - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); test.handleTouchBegin(2, 30.0, 50.0); test.handleTouchEnd(1); test.handleTouchEnd(2); ASSERT_EQ(test.events.size(), 0); - - printf("OK\n"); } -void testTwoTapSlowEnd() +TEST(GestureHandler, twoTapSlowEnd) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); test.handleTouchBegin(2, 30.0, 50.0); test.handleTouchEnd(1); usleep(500000); - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); test.handleTouchEnd(2); ASSERT_EQ(test.events.size(), 0); - - printf("OK\n"); } -void testTwoTapTimeout() +TEST(GestureHandler, twoTapTimeout) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); test.handleTouchBegin(2, 30.0, 50.0); usleep(1500000); - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); test.handleTouchEnd(1); test.handleTouchEnd(2); ASSERT_EQ(test.events.size(), 0); - - printf("OK\n"); } -void testThreeTapNormal() +TEST(GestureHandler, threeTapNormal) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); test.handleTouchBegin(2, 30.0, 50.0); test.handleTouchBegin(3, 40.0, 40.0); @@ -190,30 +163,26 @@ void testThreeTapNormal() ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GestureThreeTap); - ASSERT_EQ(test.events[0].eventX, 30.0); - ASSERT_EQ(test.events[0].eventY, 40.0); - - ASSERT_EQ(test.events[1].type, GestureEnd); - ASSERT_EQ(test.events[1].gesture, GestureThreeTap); - ASSERT_EQ(test.events[1].eventX, 30.0); - ASSERT_EQ(test.events[1].eventY, 40.0); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GestureThreeTap); + EXPECT_EQ(test.events[0].eventX, 30.0); + EXPECT_EQ(test.events[0].eventY, 40.0); - printf("OK\n"); + EXPECT_EQ(test.events[1].type, GestureEnd); + EXPECT_EQ(test.events[1].gesture, GestureThreeTap); + EXPECT_EQ(test.events[1].eventX, 30.0); + EXPECT_EQ(test.events[1].eventY, 40.0); } -void testThreeTapSlowBegin() +TEST(GestureHandler, threeTapSlowBegin) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); test.handleTouchBegin(2, 30.0, 50.0); usleep(500000); - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); test.handleTouchBegin(3, 40.0, 40.0); test.handleTouchEnd(1); @@ -221,16 +190,12 @@ void testThreeTapSlowBegin() test.handleTouchEnd(3); ASSERT_EQ(test.events.size(), 0); - - printf("OK\n"); } -void testThreeTapSlowEnd() +TEST(GestureHandler, threeTapSlowEnd) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); test.handleTouchBegin(2, 30.0, 50.0); test.handleTouchBegin(3, 40.0, 40.0); @@ -238,21 +203,17 @@ void testThreeTapSlowEnd() test.handleTouchEnd(2); usleep(500000); - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); test.handleTouchEnd(3); ASSERT_EQ(test.events.size(), 0); - - printf("OK\n"); } -void testThreeTapDrag() +TEST(GestureHandler, threeTapDrag) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); test.handleTouchBegin(2, 30.0, 50.0); test.handleTouchBegin(3, 40.0, 40.0); @@ -266,38 +227,30 @@ void testThreeTapDrag() test.handleTouchEnd(3); ASSERT_EQ(test.events.size(), 0); - - printf("OK\n"); } -void testThreeTapTimeout() +TEST(GestureHandler, threeTapTimeout) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); test.handleTouchBegin(2, 30.0, 50.0); test.handleTouchBegin(3, 40.0, 40.0); usleep(1500000); - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); test.handleTouchEnd(1); test.handleTouchEnd(2); test.handleTouchEnd(3); ASSERT_EQ(test.events.size(), 0); - - printf("OK\n"); } -void testDragHoriz() +TEST(GestureHandler, dragHoriz) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); ASSERT_EQ(test.events.size(), 0); @@ -310,15 +263,15 @@ void testDragHoriz() ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GestureDrag); - ASSERT_EQ(test.events[0].eventX, 20.0); - ASSERT_EQ(test.events[0].eventY, 30.0); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GestureDrag); + EXPECT_EQ(test.events[0].eventX, 20.0); + EXPECT_EQ(test.events[0].eventY, 30.0); - ASSERT_EQ(test.events[1].type, GestureUpdate); - ASSERT_EQ(test.events[1].gesture, GestureDrag); - ASSERT_EQ(test.events[1].eventX, 80.0); - ASSERT_EQ(test.events[1].eventY, 30.0); + EXPECT_EQ(test.events[1].type, GestureUpdate); + EXPECT_EQ(test.events[1].gesture, GestureDrag); + EXPECT_EQ(test.events[1].eventX, 80.0); + EXPECT_EQ(test.events[1].eventY, 30.0); test.events.clear(); @@ -326,20 +279,16 @@ void testDragHoriz() ASSERT_EQ(test.events.size(), 1); - ASSERT_EQ(test.events[0].type, GestureEnd); - ASSERT_EQ(test.events[0].gesture, GestureDrag); - ASSERT_EQ(test.events[0].eventX, 80.0); - ASSERT_EQ(test.events[0].eventY, 30.0); - - printf("OK\n"); + EXPECT_EQ(test.events[0].type, GestureEnd); + EXPECT_EQ(test.events[0].gesture, GestureDrag); + EXPECT_EQ(test.events[0].eventX, 80.0); + EXPECT_EQ(test.events[0].eventY, 30.0); } -void testDragVert() +TEST(GestureHandler, dragVert) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); ASSERT_EQ(test.events.size(), 0); @@ -352,15 +301,15 @@ void testDragVert() ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GestureDrag); - ASSERT_EQ(test.events[0].eventX, 20.0); - ASSERT_EQ(test.events[0].eventY, 30.0); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GestureDrag); + EXPECT_EQ(test.events[0].eventX, 20.0); + EXPECT_EQ(test.events[0].eventY, 30.0); - ASSERT_EQ(test.events[1].type, GestureUpdate); - ASSERT_EQ(test.events[1].gesture, GestureDrag); - ASSERT_EQ(test.events[1].eventX, 20.0); - ASSERT_EQ(test.events[1].eventY, 90.0); + EXPECT_EQ(test.events[1].type, GestureUpdate); + EXPECT_EQ(test.events[1].gesture, GestureDrag); + EXPECT_EQ(test.events[1].eventX, 20.0); + EXPECT_EQ(test.events[1].eventY, 90.0); test.events.clear(); @@ -368,20 +317,16 @@ void testDragVert() ASSERT_EQ(test.events.size(), 1); - ASSERT_EQ(test.events[0].type, GestureEnd); - ASSERT_EQ(test.events[0].gesture, GestureDrag); - ASSERT_EQ(test.events[0].eventX, 20.0); - ASSERT_EQ(test.events[0].eventY, 90.0); - - printf("OK\n"); + EXPECT_EQ(test.events[0].type, GestureEnd); + EXPECT_EQ(test.events[0].gesture, GestureDrag); + EXPECT_EQ(test.events[0].eventX, 20.0); + EXPECT_EQ(test.events[0].eventY, 90.0); } -void testDragDiag() +TEST(GestureHandler, dragDiag) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 120.0, 130.0); ASSERT_EQ(test.events.size(), 0); @@ -394,15 +339,15 @@ void testDragDiag() ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GestureDrag); - ASSERT_EQ(test.events[0].eventX, 120.0); - ASSERT_EQ(test.events[0].eventY, 130.0); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GestureDrag); + EXPECT_EQ(test.events[0].eventX, 120.0); + EXPECT_EQ(test.events[0].eventY, 130.0); - ASSERT_EQ(test.events[1].type, GestureUpdate); - ASSERT_EQ(test.events[1].gesture, GestureDrag); - ASSERT_EQ(test.events[1].eventX, 60.0); - ASSERT_EQ(test.events[1].eventY, 70.0); + EXPECT_EQ(test.events[1].type, GestureUpdate); + EXPECT_EQ(test.events[1].gesture, GestureDrag); + EXPECT_EQ(test.events[1].eventX, 60.0); + EXPECT_EQ(test.events[1].eventY, 70.0); test.events.clear(); @@ -410,33 +355,29 @@ void testDragDiag() ASSERT_EQ(test.events.size(), 1); - ASSERT_EQ(test.events[0].type, GestureEnd); - ASSERT_EQ(test.events[0].gesture, GestureDrag); - ASSERT_EQ(test.events[0].eventX, 60.0); - ASSERT_EQ(test.events[0].eventY, 70.0); - - printf("OK\n"); + EXPECT_EQ(test.events[0].type, GestureEnd); + EXPECT_EQ(test.events[0].gesture, GestureDrag); + EXPECT_EQ(test.events[0].eventX, 60.0); + EXPECT_EQ(test.events[0].eventY, 70.0); } -void testLongPressNormal() +TEST(GestureHandler, longPressNormal) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); ASSERT_EQ(test.events.size(), 0); usleep(1500000); - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); ASSERT_EQ(test.events.size(), 1); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GestureLongPress); - ASSERT_EQ(test.events[0].eventX, 20.0); - ASSERT_EQ(test.events[0].eventY, 30.0); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GestureLongPress); + EXPECT_EQ(test.events[0].eventX, 20.0); + EXPECT_EQ(test.events[0].eventY, 30.0); test.events.clear(); @@ -444,33 +385,29 @@ void testLongPressNormal() ASSERT_EQ(test.events.size(), 1); - ASSERT_EQ(test.events[0].type, GestureEnd); - ASSERT_EQ(test.events[0].gesture, GestureLongPress); - ASSERT_EQ(test.events[0].eventX, 20.0); - ASSERT_EQ(test.events[0].eventY, 30.0); - - printf("OK\n"); + EXPECT_EQ(test.events[0].type, GestureEnd); + EXPECT_EQ(test.events[0].gesture, GestureLongPress); + EXPECT_EQ(test.events[0].eventX, 20.0); + EXPECT_EQ(test.events[0].eventY, 30.0); } -void testLongPressDrag() +TEST(GestureHandler, longPressDrag) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); ASSERT_EQ(test.events.size(), 0); usleep(1500000); - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); ASSERT_EQ(test.events.size(), 1); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GestureLongPress); - ASSERT_EQ(test.events[0].eventX, 20.0); - ASSERT_EQ(test.events[0].eventY, 30.0); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GestureLongPress); + EXPECT_EQ(test.events[0].eventX, 20.0); + EXPECT_EQ(test.events[0].eventY, 30.0); test.events.clear(); @@ -478,10 +415,10 @@ void testLongPressDrag() ASSERT_EQ(test.events.size(), 1); - ASSERT_EQ(test.events[0].type, GestureUpdate); - ASSERT_EQ(test.events[0].gesture, GestureLongPress); - ASSERT_EQ(test.events[0].eventX, 120.0); - ASSERT_EQ(test.events[0].eventY, 50.0); + EXPECT_EQ(test.events[0].type, GestureUpdate); + EXPECT_EQ(test.events[0].gesture, GestureLongPress); + EXPECT_EQ(test.events[0].eventX, 120.0); + EXPECT_EQ(test.events[0].eventY, 50.0); test.events.clear(); @@ -489,20 +426,16 @@ void testLongPressDrag() ASSERT_EQ(test.events.size(), 1); - ASSERT_EQ(test.events[0].type, GestureEnd); - ASSERT_EQ(test.events[0].gesture, GestureLongPress); - ASSERT_EQ(test.events[0].eventX, 120.0); - ASSERT_EQ(test.events[0].eventY, 50.0); - - printf("OK\n"); + EXPECT_EQ(test.events[0].type, GestureEnd); + EXPECT_EQ(test.events[0].gesture, GestureLongPress); + EXPECT_EQ(test.events[0].eventX, 120.0); + EXPECT_EQ(test.events[0].eventY, 50.0); } -void testTwoDragFastDistinctHoriz() +TEST(GestureHandler, twoDragFastDistinctHoriz) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); test.handleTouchBegin(2, 30.0, 30.0); @@ -521,19 +454,19 @@ void testTwoDragFastDistinctHoriz() ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GestureTwoDrag); - ASSERT_EQ(test.events[0].eventX, 25.0); - ASSERT_EQ(test.events[0].eventY, 30.0); - ASSERT_EQ(test.events[0].magnitudeX, 0.0); - ASSERT_EQ(test.events[0].magnitudeY, 0.0); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GestureTwoDrag); + EXPECT_EQ(test.events[0].eventX, 25.0); + EXPECT_EQ(test.events[0].eventY, 30.0); + EXPECT_EQ(test.events[0].magnitudeX, 0.0); + EXPECT_EQ(test.events[0].magnitudeY, 0.0); - ASSERT_EQ(test.events[1].type, GestureUpdate); - ASSERT_EQ(test.events[1].gesture, GestureTwoDrag); - ASSERT_EQ(test.events[1].eventX, 25.0); - ASSERT_EQ(test.events[1].eventY, 30.0); - ASSERT_EQ(test.events[1].magnitudeX, 60.0); - ASSERT_EQ(test.events[1].magnitudeY, 0.0); + EXPECT_EQ(test.events[1].type, GestureUpdate); + EXPECT_EQ(test.events[1].gesture, GestureTwoDrag); + EXPECT_EQ(test.events[1].eventX, 25.0); + EXPECT_EQ(test.events[1].eventY, 30.0); + EXPECT_EQ(test.events[1].magnitudeX, 60.0); + EXPECT_EQ(test.events[1].magnitudeY, 0.0); test.events.clear(); @@ -541,22 +474,18 @@ void testTwoDragFastDistinctHoriz() ASSERT_EQ(test.events.size(), 1); - ASSERT_EQ(test.events[0].type, GestureEnd); - ASSERT_EQ(test.events[0].gesture, GestureTwoDrag); - ASSERT_EQ(test.events[0].eventX, 25.0); - ASSERT_EQ(test.events[0].eventY, 30.0); - ASSERT_EQ(test.events[0].magnitudeX, 60.0); - ASSERT_EQ(test.events[0].magnitudeY, 0.0); - - printf("OK\n"); + EXPECT_EQ(test.events[0].type, GestureEnd); + EXPECT_EQ(test.events[0].gesture, GestureTwoDrag); + EXPECT_EQ(test.events[0].eventX, 25.0); + EXPECT_EQ(test.events[0].eventY, 30.0); + EXPECT_EQ(test.events[0].magnitudeX, 60.0); + EXPECT_EQ(test.events[0].magnitudeY, 0.0); } -void testTwoDragFastDistinctVert() +TEST(GestureHandler, twoDragFastDistinctVert) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); test.handleTouchBegin(2, 30.0, 30.0); @@ -574,19 +503,19 @@ void testTwoDragFastDistinctVert() ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GestureTwoDrag); - ASSERT_EQ(test.events[0].eventX, 25.0); - ASSERT_EQ(test.events[0].eventY, 30.0); - ASSERT_EQ(test.events[0].magnitudeX, 0.0); - ASSERT_EQ(test.events[0].magnitudeY, 0.0); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GestureTwoDrag); + EXPECT_EQ(test.events[0].eventX, 25.0); + EXPECT_EQ(test.events[0].eventY, 30.0); + EXPECT_EQ(test.events[0].magnitudeX, 0.0); + EXPECT_EQ(test.events[0].magnitudeY, 0.0); - ASSERT_EQ(test.events[1].type, GestureUpdate); - ASSERT_EQ(test.events[1].gesture, GestureTwoDrag); - ASSERT_EQ(test.events[1].eventX, 25.0); - ASSERT_EQ(test.events[1].eventY, 30.0); - ASSERT_EQ(test.events[1].magnitudeX, 0.0); - ASSERT_EQ(test.events[1].magnitudeY, 65.0); + EXPECT_EQ(test.events[1].type, GestureUpdate); + EXPECT_EQ(test.events[1].gesture, GestureTwoDrag); + EXPECT_EQ(test.events[1].eventX, 25.0); + EXPECT_EQ(test.events[1].eventY, 30.0); + EXPECT_EQ(test.events[1].magnitudeX, 0.0); + EXPECT_EQ(test.events[1].magnitudeY, 65.0); test.events.clear(); @@ -594,22 +523,18 @@ void testTwoDragFastDistinctVert() ASSERT_EQ(test.events.size(), 1); - ASSERT_EQ(test.events[0].type, GestureEnd); - ASSERT_EQ(test.events[0].gesture, GestureTwoDrag); - ASSERT_EQ(test.events[0].eventX, 25.0); - ASSERT_EQ(test.events[0].eventY, 30.0); - ASSERT_EQ(test.events[0].magnitudeX, 0.0); - ASSERT_EQ(test.events[0].magnitudeY, 65.0); - - printf("OK\n"); + EXPECT_EQ(test.events[0].type, GestureEnd); + EXPECT_EQ(test.events[0].gesture, GestureTwoDrag); + EXPECT_EQ(test.events[0].eventX, 25.0); + EXPECT_EQ(test.events[0].eventY, 30.0); + EXPECT_EQ(test.events[0].magnitudeX, 0.0); + EXPECT_EQ(test.events[0].magnitudeY, 65.0); } -void testTwoDragFastDistinctDiag() +TEST(GestureHandler, twoDragFastDistinctDiag) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 120.0, 130.0); test.handleTouchBegin(2, 130.0, 130.0); @@ -627,19 +552,19 @@ void testTwoDragFastDistinctDiag() ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GestureTwoDrag); - ASSERT_EQ(test.events[0].eventX, 125.0); - ASSERT_EQ(test.events[0].eventY, 130.0); - ASSERT_EQ(test.events[0].magnitudeX, 0.0); - ASSERT_EQ(test.events[0].magnitudeY, 0.0); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GestureTwoDrag); + EXPECT_EQ(test.events[0].eventX, 125.0); + EXPECT_EQ(test.events[0].eventY, 130.0); + EXPECT_EQ(test.events[0].magnitudeX, 0.0); + EXPECT_EQ(test.events[0].magnitudeY, 0.0); - ASSERT_EQ(test.events[1].type, GestureUpdate); - ASSERT_EQ(test.events[1].gesture, GestureTwoDrag); - ASSERT_EQ(test.events[1].eventX, 125.0); - ASSERT_EQ(test.events[1].eventY, 130.0); - ASSERT_EQ(test.events[1].magnitudeX, -55.0); - ASSERT_EQ(test.events[1].magnitudeY, -50.0); + EXPECT_EQ(test.events[1].type, GestureUpdate); + EXPECT_EQ(test.events[1].gesture, GestureTwoDrag); + EXPECT_EQ(test.events[1].eventX, 125.0); + EXPECT_EQ(test.events[1].eventY, 130.0); + EXPECT_EQ(test.events[1].magnitudeX, -55.0); + EXPECT_EQ(test.events[1].magnitudeY, -50.0); test.events.clear(); @@ -647,22 +572,18 @@ void testTwoDragFastDistinctDiag() ASSERT_EQ(test.events.size(), 1); - ASSERT_EQ(test.events[0].type, GestureEnd); - ASSERT_EQ(test.events[0].gesture, GestureTwoDrag); - ASSERT_EQ(test.events[0].eventX, 125.0); - ASSERT_EQ(test.events[0].eventY, 130.0); - ASSERT_EQ(test.events[0].magnitudeX, -55.0); - ASSERT_EQ(test.events[0].magnitudeY, -50.0); - - printf("OK\n"); + EXPECT_EQ(test.events[0].type, GestureEnd); + EXPECT_EQ(test.events[0].gesture, GestureTwoDrag); + EXPECT_EQ(test.events[0].eventX, 125.0); + EXPECT_EQ(test.events[0].eventY, 130.0); + EXPECT_EQ(test.events[0].magnitudeX, -55.0); + EXPECT_EQ(test.events[0].magnitudeY, -50.0); } -void testTwoDragFastAlmost() +TEST(GestureHandler, twoDragFastAlmost) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); test.handleTouchBegin(2, 30.0, 30.0); test.handleTouchUpdate(1, 80.0, 30.0); @@ -673,19 +594,15 @@ void testTwoDragFastAlmost() ASSERT_EQ(test.events.size(), 0); usleep(500000); - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); ASSERT_EQ(test.events.size(), 0); - - printf("OK\n"); } -void testTwoDragSlowHoriz() +TEST(GestureHandler, twoDragSlowHoriz) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 50.0, 40.0); test.handleTouchBegin(2, 60.0, 40.0); test.handleTouchUpdate(2, 80.0, 40.0); @@ -694,32 +611,29 @@ void testTwoDragSlowHoriz() ASSERT_EQ(test.events.size(), 0); usleep(60000); // 60ms - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GestureTwoDrag); - ASSERT_EQ(test.events[0].eventX, 55.0); - ASSERT_EQ(test.events[0].eventY, 40.0); - ASSERT_EQ(test.events[0].magnitudeX, 0.0); - ASSERT_EQ(test.events[0].magnitudeY, 0.0); - - ASSERT_EQ(test.events[1].type, GestureUpdate); - ASSERT_EQ(test.events[1].gesture, GestureTwoDrag); - ASSERT_EQ(test.events[1].eventX, 55.0); - ASSERT_EQ(test.events[1].eventY, 40.0); - ASSERT_EQ(test.events[1].magnitudeX, 40.0); - ASSERT_EQ(test.events[1].magnitudeY, 0.0); - - printf("OK\n"); + + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GestureTwoDrag); + EXPECT_EQ(test.events[0].eventX, 55.0); + EXPECT_EQ(test.events[0].eventY, 40.0); + EXPECT_EQ(test.events[0].magnitudeX, 0.0); + EXPECT_EQ(test.events[0].magnitudeY, 0.0); + + EXPECT_EQ(test.events[1].type, GestureUpdate); + EXPECT_EQ(test.events[1].gesture, GestureTwoDrag); + EXPECT_EQ(test.events[1].eventX, 55.0); + EXPECT_EQ(test.events[1].eventY, 40.0); + EXPECT_EQ(test.events[1].magnitudeX, 40.0); + EXPECT_EQ(test.events[1].magnitudeY, 0.0); } -void testTwoDragSlowVert() +TEST(GestureHandler, twoDragSlowVert) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 40.0, 40.0); test.handleTouchBegin(2, 40.0, 60.0); test.handleTouchUpdate(2, 40.0, 80.0); @@ -728,32 +642,29 @@ void testTwoDragSlowVert() ASSERT_EQ(test.events.size(), 0); usleep(60000); // 60ms - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GestureTwoDrag); - ASSERT_EQ(test.events[0].eventX, 40.0); - ASSERT_EQ(test.events[0].eventY, 50.0); - ASSERT_EQ(test.events[0].magnitudeX, 0.0); - ASSERT_EQ(test.events[0].magnitudeY, 0.0); - - ASSERT_EQ(test.events[1].type, GestureUpdate); - ASSERT_EQ(test.events[1].gesture, GestureTwoDrag); - ASSERT_EQ(test.events[1].eventX, 40.0); - ASSERT_EQ(test.events[1].eventY, 50.0); - ASSERT_EQ(test.events[1].magnitudeX, 0.0); - ASSERT_EQ(test.events[1].magnitudeY, 40.0); - - printf("OK\n"); + + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GestureTwoDrag); + EXPECT_EQ(test.events[0].eventX, 40.0); + EXPECT_EQ(test.events[0].eventY, 50.0); + EXPECT_EQ(test.events[0].magnitudeX, 0.0); + EXPECT_EQ(test.events[0].magnitudeY, 0.0); + + EXPECT_EQ(test.events[1].type, GestureUpdate); + EXPECT_EQ(test.events[1].gesture, GestureTwoDrag); + EXPECT_EQ(test.events[1].eventX, 40.0); + EXPECT_EQ(test.events[1].eventY, 50.0); + EXPECT_EQ(test.events[1].magnitudeX, 0.0); + EXPECT_EQ(test.events[1].magnitudeY, 40.0); } -void testTwoDragSlowDiag() +TEST(GestureHandler, twoDragSlowDiag) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 50.0, 40.0); test.handleTouchBegin(2, 40.0, 60.0); test.handleTouchUpdate(1, 70.0, 60.0); @@ -762,52 +673,45 @@ void testTwoDragSlowDiag() ASSERT_EQ(test.events.size(), 0); usleep(60000); // 60ms - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GestureTwoDrag); - ASSERT_EQ(test.events[0].eventX, 45.0); - ASSERT_EQ(test.events[0].eventY, 50.0); - ASSERT_EQ(test.events[0].magnitudeX, 0.0); - ASSERT_EQ(test.events[0].magnitudeY, 0.0); - - ASSERT_EQ(test.events[1].type, GestureUpdate); - ASSERT_EQ(test.events[1].gesture, GestureTwoDrag); - ASSERT_EQ(test.events[1].eventX, 45.0); - ASSERT_EQ(test.events[1].eventY, 50.0); - ASSERT_EQ(test.events[1].magnitudeX, 35.0); - ASSERT_EQ(test.events[1].magnitudeY, 35.0); - - printf("OK\n"); + + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GestureTwoDrag); + EXPECT_EQ(test.events[0].eventX, 45.0); + EXPECT_EQ(test.events[0].eventY, 50.0); + EXPECT_EQ(test.events[0].magnitudeX, 0.0); + EXPECT_EQ(test.events[0].magnitudeY, 0.0); + + EXPECT_EQ(test.events[1].type, GestureUpdate); + EXPECT_EQ(test.events[1].gesture, GestureTwoDrag); + EXPECT_EQ(test.events[1].eventX, 45.0); + EXPECT_EQ(test.events[1].eventY, 50.0); + EXPECT_EQ(test.events[1].magnitudeX, 35.0); + EXPECT_EQ(test.events[1].magnitudeY, 35.0); } -void testTwoDragTooSlow() +TEST(GestureHandler, twoDragTooSlow) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); usleep(500000); - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); test.handleTouchBegin(2, 30.0, 30.0); test.handleTouchUpdate(2, 50.0, 30.0); test.handleTouchUpdate(1, 80.0, 30.0); ASSERT_EQ(test.events.size(), 0); - - printf("OK\n"); } -void testPinchFastDistinctIn() +TEST(GestureHandler, pinchFastDistinctIn) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 0.0, 0.0); test.handleTouchBegin(2, 130.0, 130.0); @@ -822,19 +726,19 @@ void testPinchFastDistinctIn() ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GesturePinch); - ASSERT_EQ(test.events[0].eventX, 65.0); - ASSERT_EQ(test.events[0].eventY, 65.0); - ASSERT_EQ(test.events[0].magnitudeX, 130.0); - ASSERT_EQ(test.events[0].magnitudeY, 130.0); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GesturePinch); + EXPECT_EQ(test.events[0].eventX, 65.0); + EXPECT_EQ(test.events[0].eventY, 65.0); + EXPECT_EQ(test.events[0].magnitudeX, 130.0); + EXPECT_EQ(test.events[0].magnitudeY, 130.0); - ASSERT_EQ(test.events[1].type, GestureUpdate); - ASSERT_EQ(test.events[1].gesture, GesturePinch); - ASSERT_EQ(test.events[1].eventX, 65.0); - ASSERT_EQ(test.events[1].eventY, 65.0); - ASSERT_EQ(test.events[1].magnitudeX, 10.0); - ASSERT_EQ(test.events[1].magnitudeY, 30.0); + EXPECT_EQ(test.events[1].type, GestureUpdate); + EXPECT_EQ(test.events[1].gesture, GesturePinch); + EXPECT_EQ(test.events[1].eventX, 65.0); + EXPECT_EQ(test.events[1].eventY, 65.0); + EXPECT_EQ(test.events[1].magnitudeX, 10.0); + EXPECT_EQ(test.events[1].magnitudeY, 30.0); test.events.clear(); @@ -842,22 +746,18 @@ void testPinchFastDistinctIn() ASSERT_EQ(test.events.size(), 1); - ASSERT_EQ(test.events[0].type, GestureEnd); - ASSERT_EQ(test.events[0].gesture, GesturePinch); - ASSERT_EQ(test.events[0].eventX, 65.0); - ASSERT_EQ(test.events[0].eventY, 65.0); - ASSERT_EQ(test.events[0].magnitudeX, 10.0); - ASSERT_EQ(test.events[0].magnitudeY, 30.0); - - printf("OK\n"); + EXPECT_EQ(test.events[0].type, GestureEnd); + EXPECT_EQ(test.events[0].gesture, GesturePinch); + EXPECT_EQ(test.events[0].eventX, 65.0); + EXPECT_EQ(test.events[0].eventY, 65.0); + EXPECT_EQ(test.events[0].magnitudeX, 10.0); + EXPECT_EQ(test.events[0].magnitudeY, 30.0); } -void testPinchFastDistinctOut() +TEST(GestureHandler, pinchFastDistinctOut) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 100.0, 100.0); test.handleTouchBegin(2, 110.0, 100.0); @@ -872,19 +772,19 @@ void testPinchFastDistinctOut() ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GesturePinch); - ASSERT_EQ(test.events[0].eventX, 105.0); - ASSERT_EQ(test.events[0].eventY, 100.0); - ASSERT_EQ(test.events[0].magnitudeX, 10.0); - ASSERT_EQ(test.events[0].magnitudeY, 0.0); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GesturePinch); + EXPECT_EQ(test.events[0].eventX, 105.0); + EXPECT_EQ(test.events[0].eventY, 100.0); + EXPECT_EQ(test.events[0].magnitudeX, 10.0); + EXPECT_EQ(test.events[0].magnitudeY, 0.0); - ASSERT_EQ(test.events[1].type, GestureUpdate); - ASSERT_EQ(test.events[1].gesture, GesturePinch); - ASSERT_EQ(test.events[1].eventX, 105.0); - ASSERT_EQ(test.events[1].eventY, 100.0); - ASSERT_EQ(test.events[1].magnitudeX, 180.0); - ASSERT_EQ(test.events[1].magnitudeY, 180.0); + EXPECT_EQ(test.events[1].type, GestureUpdate); + EXPECT_EQ(test.events[1].gesture, GesturePinch); + EXPECT_EQ(test.events[1].eventX, 105.0); + EXPECT_EQ(test.events[1].eventY, 100.0); + EXPECT_EQ(test.events[1].magnitudeX, 180.0); + EXPECT_EQ(test.events[1].magnitudeY, 180.0); test.events.clear(); @@ -892,22 +792,18 @@ void testPinchFastDistinctOut() ASSERT_EQ(test.events.size(), 1); - ASSERT_EQ(test.events[0].type, GestureEnd); - ASSERT_EQ(test.events[0].gesture, GesturePinch); - ASSERT_EQ(test.events[0].eventX, 105.0); - ASSERT_EQ(test.events[0].eventY, 100.0); - ASSERT_EQ(test.events[0].magnitudeX, 180.0); - ASSERT_EQ(test.events[0].magnitudeY, 180.0); - - printf("OK\n"); + EXPECT_EQ(test.events[0].type, GestureEnd); + EXPECT_EQ(test.events[0].gesture, GesturePinch); + EXPECT_EQ(test.events[0].eventX, 105.0); + EXPECT_EQ(test.events[0].eventY, 100.0); + EXPECT_EQ(test.events[0].magnitudeX, 180.0); + EXPECT_EQ(test.events[0].magnitudeY, 180.0); } -void testPinchFastAlmost() +TEST(GestureHandler, pinchFastAlmost) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); test.handleTouchBegin(2, 130.0, 130.0); test.handleTouchUpdate(1, 80.0, 70.0); @@ -917,19 +813,15 @@ void testPinchFastAlmost() ASSERT_EQ(test.events.size(), 0); usleep(500000); - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); ASSERT_EQ(test.events.size(), 0); - - printf("OK\n"); } -void testPinchSlowIn() +TEST(GestureHandler, pinchSlowIn) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 0.0, 0.0); test.handleTouchBegin(2, 130.0, 130.0); @@ -941,33 +833,29 @@ void testPinchSlowIn() ASSERT_EQ(test.events.size(), 0); usleep(60000); // 60ms - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GesturePinch); - ASSERT_EQ(test.events[0].eventX, 65.0); - ASSERT_EQ(test.events[0].eventY, 65.0); - ASSERT_EQ(test.events[0].magnitudeX, 130.0); - ASSERT_EQ(test.events[0].magnitudeY, 130.0); - - ASSERT_EQ(test.events[1].type, GestureUpdate); - ASSERT_EQ(test.events[1].gesture, GesturePinch); - ASSERT_EQ(test.events[1].eventX, 65.0); - ASSERT_EQ(test.events[1].eventY, 65.0); - ASSERT_EQ(test.events[1].magnitudeX, 50.0); - ASSERT_EQ(test.events[1].magnitudeY, 90.0); - - printf("OK\n"); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GesturePinch); + EXPECT_EQ(test.events[0].eventX, 65.0); + EXPECT_EQ(test.events[0].eventY, 65.0); + EXPECT_EQ(test.events[0].magnitudeX, 130.0); + EXPECT_EQ(test.events[0].magnitudeY, 130.0); + + EXPECT_EQ(test.events[1].type, GestureUpdate); + EXPECT_EQ(test.events[1].gesture, GesturePinch); + EXPECT_EQ(test.events[1].eventX, 65.0); + EXPECT_EQ(test.events[1].eventY, 65.0); + EXPECT_EQ(test.events[1].magnitudeX, 50.0); + EXPECT_EQ(test.events[1].magnitudeY, 90.0); } -void testPinchSlowOut() +TEST(GestureHandler, pinchSlowOut) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 100.0, 130.0); test.handleTouchBegin(2, 110.0, 130.0); @@ -978,64 +866,56 @@ void testPinchSlowOut() ASSERT_EQ(test.events.size(), 0); usleep(60000); // 60ms - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GesturePinch); - ASSERT_EQ(test.events[0].eventX, 105.0); - ASSERT_EQ(test.events[0].eventY, 130.0); - ASSERT_EQ(test.events[0].magnitudeX, 10.0); - ASSERT_EQ(test.events[0].magnitudeY, 0.0); - - ASSERT_EQ(test.events[1].type, GestureUpdate); - ASSERT_EQ(test.events[1].gesture, GesturePinch); - ASSERT_EQ(test.events[1].eventX, 105.0); - ASSERT_EQ(test.events[1].eventY, 130.0); - ASSERT_EQ(test.events[1].magnitudeX, 100.0); - ASSERT_EQ(test.events[1].magnitudeY, 0.0); - - printf("OK\n"); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GesturePinch); + EXPECT_EQ(test.events[0].eventX, 105.0); + EXPECT_EQ(test.events[0].eventY, 130.0); + EXPECT_EQ(test.events[0].magnitudeX, 10.0); + EXPECT_EQ(test.events[0].magnitudeY, 0.0); + + EXPECT_EQ(test.events[1].type, GestureUpdate); + EXPECT_EQ(test.events[1].gesture, GesturePinch); + EXPECT_EQ(test.events[1].eventX, 105.0); + EXPECT_EQ(test.events[1].eventY, 130.0); + EXPECT_EQ(test.events[1].magnitudeX, 100.0); + EXPECT_EQ(test.events[1].magnitudeY, 0.0); } -void testPinchTooSlow() +TEST(GestureHandler, pinchTooSlow) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 0.0, 0.0); usleep(60000); // 60ms - rfb::Timer::checkTimeouts(); + core::Timer::checkTimeouts(); test.handleTouchBegin(2, 130.0, 130.0); test.handleTouchUpdate(2, 100.0, 130.0); test.handleTouchUpdate(1, 50.0, 40.0); ASSERT_EQ(test.events.size(), 0); - - printf("OK\n"); } -void testExtraIgnore() +TEST(GestureHandler, extraIgnore) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); test.handleTouchUpdate(1, 40.0, 30.0); test.handleTouchUpdate(1, 80.0, 30.0); ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GestureDrag); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GestureDrag); - ASSERT_EQ(test.events[1].type, GestureUpdate); - ASSERT_EQ(test.events[1].gesture, GestureDrag); + EXPECT_EQ(test.events[1].type, GestureUpdate); + EXPECT_EQ(test.events[1].gesture, GestureDrag); test.events.clear(); @@ -1047,10 +927,10 @@ void testExtraIgnore() ASSERT_EQ(test.events.size(), 1); - ASSERT_EQ(test.events[0].type, GestureUpdate); - ASSERT_EQ(test.events[0].gesture, GestureDrag); - ASSERT_EQ(test.events[0].eventX, 100.0); - ASSERT_EQ(test.events[0].eventY, 50.0); + EXPECT_EQ(test.events[0].type, GestureUpdate); + EXPECT_EQ(test.events[0].gesture, GestureDrag); + EXPECT_EQ(test.events[0].eventX, 100.0); + EXPECT_EQ(test.events[0].eventY, 50.0); test.events.clear(); @@ -1058,20 +938,16 @@ void testExtraIgnore() ASSERT_EQ(test.events.size(), 1); - ASSERT_EQ(test.events[0].type, GestureEnd); - ASSERT_EQ(test.events[0].gesture, GestureDrag); - ASSERT_EQ(test.events[0].eventX, 100.0); - ASSERT_EQ(test.events[0].eventY, 50.0); - - printf("OK\n"); + EXPECT_EQ(test.events[0].type, GestureEnd); + EXPECT_EQ(test.events[0].gesture, GestureDrag); + EXPECT_EQ(test.events[0].eventX, 100.0); + EXPECT_EQ(test.events[0].eventY, 50.0); } -void testIgnoreWhenAwaitingGestureEnd() +TEST(GestureHandler, ignoreWhenAwaitingGestureEnd) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); test.handleTouchBegin(2, 30.0, 30.0); test.handleTouchUpdate(1, 40.0, 30.0); @@ -1080,11 +956,11 @@ void testIgnoreWhenAwaitingGestureEnd() ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GestureTwoDrag); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GestureTwoDrag); - ASSERT_EQ(test.events[1].type, GestureUpdate); - ASSERT_EQ(test.events[1].gesture, GestureTwoDrag); + EXPECT_EQ(test.events[1].type, GestureUpdate); + EXPECT_EQ(test.events[1].gesture, GestureTwoDrag); test.events.clear(); @@ -1092,8 +968,8 @@ void testIgnoreWhenAwaitingGestureEnd() ASSERT_EQ(test.events.size(), 1); - ASSERT_EQ(test.events[0].type, GestureEnd); - ASSERT_EQ(test.events[0].gesture, GestureTwoDrag); + EXPECT_EQ(test.events[0].type, GestureEnd); + EXPECT_EQ(test.events[0].gesture, GestureTwoDrag); test.events.clear(); @@ -1101,27 +977,23 @@ void testIgnoreWhenAwaitingGestureEnd() test.handleTouchEnd(3); ASSERT_EQ(test.events.size(), 0); - - printf("OK\n"); } -void testIgnoreAfterGesture() +TEST(GestureHandler, ignoreAfterGesture) { TestClass test; - printf("%s: ", __func__); - test.handleTouchBegin(1, 20.0, 30.0); test.handleTouchUpdate(1, 40.0, 30.0); test.handleTouchUpdate(1, 80.0, 30.0); ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GestureDrag); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GestureDrag); - ASSERT_EQ(test.events[1].type, GestureUpdate); - ASSERT_EQ(test.events[1].gesture, GestureDrag); + EXPECT_EQ(test.events[1].type, GestureUpdate); + EXPECT_EQ(test.events[1].gesture, GestureDrag); test.events.clear(); @@ -1134,10 +1006,10 @@ void testIgnoreAfterGesture() ASSERT_EQ(test.events.size(), 1); - ASSERT_EQ(test.events[0].type, GestureUpdate); - ASSERT_EQ(test.events[0].gesture, GestureDrag); - ASSERT_EQ(test.events[0].eventX, 100.0); - ASSERT_EQ(test.events[0].eventY, 50.0); + EXPECT_EQ(test.events[0].type, GestureUpdate); + EXPECT_EQ(test.events[0].gesture, GestureDrag); + EXPECT_EQ(test.events[0].eventX, 100.0); + EXPECT_EQ(test.events[0].eventY, 50.0); test.events.clear(); @@ -1145,10 +1017,10 @@ void testIgnoreAfterGesture() ASSERT_EQ(test.events.size(), 1); - ASSERT_EQ(test.events[0].type, GestureEnd); - ASSERT_EQ(test.events[0].gesture, GestureDrag); - ASSERT_EQ(test.events[0].eventX, 100.0); - ASSERT_EQ(test.events[0].eventY, 50.0); + EXPECT_EQ(test.events[0].type, GestureEnd); + EXPECT_EQ(test.events[0].gesture, GestureDrag); + EXPECT_EQ(test.events[0].eventX, 100.0); + EXPECT_EQ(test.events[0].eventY, 50.0); // End ignored event test.handleTouchEnd(2); @@ -1161,88 +1033,14 @@ void testIgnoreAfterGesture() ASSERT_EQ(test.events.size(), 2); - ASSERT_EQ(test.events[0].type, GestureBegin); - ASSERT_EQ(test.events[0].gesture, GestureOneTap); - ASSERT_EQ(test.events[1].type, GestureEnd); - ASSERT_EQ(test.events[1].gesture, GestureOneTap); - - printf("OK\n"); -} - -void testOneTap() -{ - testOneTapNormal(); -} - -void testTwoTap() -{ - testTwoTapNormal(); - testTwoTapSlowBegin(); - testTwoTapSlowEnd(); - testTwoTapTimeout(); -} - -void testThreeTap() -{ - testThreeTapNormal(); - testThreeTapSlowBegin(); - testThreeTapSlowEnd(); - testThreeTapDrag(); - testThreeTapTimeout(); -} - -void testDrag() -{ - testDragHoriz(); - testDragVert(); - testDragDiag(); -} - -void testLongPress() -{ - testLongPressNormal(); - testLongPressDrag(); -} - -void testTwoDrag() -{ - testTwoDragFastDistinctHoriz(); - testTwoDragFastDistinctVert(); - testTwoDragFastDistinctDiag(); - testTwoDragFastAlmost(); - testTwoDragSlowHoriz(); - testTwoDragSlowVert(); - testTwoDragSlowDiag(); - testTwoDragTooSlow(); -} - -void testPinch() -{ - testPinchFastDistinctIn(); - testPinchFastDistinctOut(); - testPinchFastAlmost(); - testPinchSlowIn(); - testPinchSlowOut(); - testPinchTooSlow(); -} - -void testIgnore() -{ - testExtraIgnore(); - testIgnoreWhenAwaitingGestureEnd(); - testIgnoreAfterGesture(); + EXPECT_EQ(test.events[0].type, GestureBegin); + EXPECT_EQ(test.events[0].gesture, GestureOneTap); + EXPECT_EQ(test.events[1].type, GestureEnd); + EXPECT_EQ(test.events[1].gesture, GestureOneTap); } -int main(int /*argc*/, char** /*argv*/) +int main(int argc, char** argv) { - testOneTap(); - testTwoTap(); - testThreeTap(); - testDrag(); - testLongPress(); - testTwoDrag(); - testPinch(); - testIgnore(); - - return 0; + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } diff --git a/tests/unit/hostport.cxx b/tests/unit/hostport.cxx index d82c3d51..164a7877 100644 --- a/tests/unit/hostport.cxx +++ b/tests/unit/hostport.cxx @@ -1,4 +1,4 @@ -/* Copyright 2016 Pierre Ossman <ossman@cendio.se> for Cendio AB +/* Copyright 2016-2025 Pierre Ossman <ossman@cendio.se> for Cendio AB * * This is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -20,75 +20,108 @@ #include <config.h> #endif -#include <stdio.h> +#include <gtest/gtest.h> -#include <rfb/Hostname.h> +#include <network/TcpSocket.h> -static void doTest(const char* hostAndPort, - const char* expectedHost, int expectedPort) +struct result { + std::string host; + int port; +}; + +static bool operator==(const result& a, const result& b) +{ + return a.host == b.host && a.port == b.port; +} + +static std::ostream& operator<<(std::ostream& os, const result& r) +{ + return os << r.host << ":" << r.port; +} + +static result getHostAndPort(const char* hostAndPort) +{ + std::string host; + int port; + network::getHostAndPort(hostAndPort, &host, &port); + return {host, port}; +} + +TEST(HostPost, localDisplay) +{ + EXPECT_EQ(getHostAndPort(":5"), result({"localhost", 5905})); +} + +TEST(HostPost, noDisplay) +{ + EXPECT_EQ(getHostAndPort("1.2.3.4"), result({"1.2.3.4", 5900})); +} + +TEST(HostPost, display) +{ + EXPECT_EQ(getHostAndPort("1.2.3.4:5"), result({"1.2.3.4", 5905})); + EXPECT_EQ(getHostAndPort("1.2.3.4:99"), result({"1.2.3.4", 5999})); + EXPECT_EQ(getHostAndPort("1.2.3.4:100"), result({"1.2.3.4", 100})); + EXPECT_EQ(getHostAndPort("1.2.3.4:5901"), result({"1.2.3.4", 5901})); +} + +TEST(HostPost, port) { - std::string host; - int port; + EXPECT_EQ(getHostAndPort("1.2.3.4::5"), result({"1.2.3.4", 5})); + EXPECT_EQ(getHostAndPort("1.2.3.4::99"), result({"1.2.3.4", 99})); + EXPECT_EQ(getHostAndPort("1.2.3.4::5901"), result({"1.2.3.4", 5901})); +} - printf("\"%s\": ", hostAndPort); +TEST(HostPost, bracketedIpv4) +{ + EXPECT_EQ(getHostAndPort("[1.2.3.4]"), result({"1.2.3.4", 5900})); + EXPECT_EQ(getHostAndPort("[1.2.3.4]:5"), result({"1.2.3.4", 5905})); + EXPECT_EQ(getHostAndPort("[1.2.3.4]:100"), result({"1.2.3.4", 100})); + EXPECT_EQ(getHostAndPort("[1.2.3.4]::5"), result({"1.2.3.4", 5})); + EXPECT_EQ(getHostAndPort("[1.2.3.4]::100"), result({"1.2.3.4", 100})); +} - rfb::getHostAndPort(hostAndPort, &host, &port); +TEST(HostPost, portOne) +{ + // Ambigiuous. For now we'll keep the old behaviour... + EXPECT_EQ(getHostAndPort("::1"), result({"localhost", 1})); +} - if (host != expectedHost) - printf("FAILED (\"%s\" != \"%s\")", host.c_str(), expectedHost); - else if (port != expectedPort) - printf("FAILED (%d != %d)", port, expectedPort); - else - printf("OK"); - printf("\n"); - fflush(stdout); +TEST(HostPost, bareIpv6) +{ + EXPECT_EQ(getHostAndPort("2001:1234::20:1"), result({"2001:1234::20:1", 5900})); +} + +TEST(HostPost, bracketedIpv6) +{ + EXPECT_EQ(getHostAndPort("[::1]"), result({"::1", 5900})); + EXPECT_EQ(getHostAndPort("[2001:1234::20:1]"), result({"2001:1234::20:1", 5900})); +} + +TEST(HostPost, ipv6WithDisplay) +{ + EXPECT_EQ(getHostAndPort("[2001:1234::20:1]:5"), result({"2001:1234::20:1", 5905})); + EXPECT_EQ(getHostAndPort("[2001:1234::20:1]:99"), result({"2001:1234::20:1", 5999})); + EXPECT_EQ(getHostAndPort("[2001:1234::20:1]:100"), result({"2001:1234::20:1", 100})); + EXPECT_EQ(getHostAndPort("[2001:1234::20:1]:5901"), result({"2001:1234::20:1", 5901})); +} + +TEST(HostPort, padding) +{ + EXPECT_EQ(getHostAndPort(" 1.2.3.4 "), result({"1.2.3.4", 5900})); + EXPECT_EQ(getHostAndPort(" 1.2.3.4:5901 "), result({"1.2.3.4", 5901})); + EXPECT_EQ(getHostAndPort(" 1.2.3.4 :5901 "), result({"1.2.3.4", 5901})); + EXPECT_EQ(getHostAndPort(" [1.2.3.4]:5902 "), result({"1.2.3.4", 5902})); + EXPECT_EQ(getHostAndPort(" :5903 "), result({"localhost", 5903})); + EXPECT_EQ(getHostAndPort(" ::4 "), result({"localhost", 4})); + EXPECT_EQ(getHostAndPort(" [::1] "), result({"::1", 5900})); + EXPECT_EQ(getHostAndPort(" 2001:1234::20:1 "), result({"2001:1234::20:1", 5900})); + EXPECT_EQ(getHostAndPort(" [2001:1234::20:1] "), result({"2001:1234::20:1", 5900})); + EXPECT_EQ(getHostAndPort(" [2001:1234::20:1]:5905 "), result({"2001:1234::20:1", 5905})); } -int main(int /*argc*/, char** /*argv*/) +int main(int argc, char** argv) { - doTest(":5", "localhost", 5905); - - doTest("1.2.3.4", "1.2.3.4", 5900); - - doTest("1.2.3.4:5", "1.2.3.4", 5905); - doTest("1.2.3.4:99", "1.2.3.4", 5999); - doTest("1.2.3.4:100", "1.2.3.4", 100); - doTest("1.2.3.4:5901", "1.2.3.4", 5901); - - doTest("1.2.3.4::5", "1.2.3.4", 5); - doTest("1.2.3.4::99", "1.2.3.4", 99); - doTest("1.2.3.4::5901", "1.2.3.4", 5901); - - doTest("[1.2.3.4]", "1.2.3.4", 5900); - doTest("[1.2.3.4]:5", "1.2.3.4", 5905); - doTest("[1.2.3.4]:100", "1.2.3.4", 100); - doTest("[1.2.3.4]::5", "1.2.3.4", 5); - doTest("[1.2.3.4]::100", "1.2.3.4", 100); - - // Ambigiuous. For now we'll keep the old behaviour... - doTest("::1", "localhost", 1); - - doTest("2001:1234::20:1", "2001:1234::20:1", 5900); - - doTest("[::1]", "::1", 5900); - doTest("[2001:1234::20:1]", "2001:1234::20:1", 5900); - - doTest("[2001:1234::20:1]:5", "2001:1234::20:1", 5905); - doTest("[2001:1234::20:1]:99", "2001:1234::20:1", 5999); - doTest("[2001:1234::20:1]:100", "2001:1234::20:1", 100); - doTest("[2001:1234::20:1]:5901", "2001:1234::20:1", 5901); - - doTest(" 1.2.3.4 ", "1.2.3.4", 5900); - doTest(" 1.2.3.4:5901 ", "1.2.3.4", 5901); - doTest(" 1.2.3.4: 5901 ", "1.2.3.4", 5901); - doTest(" 1.2.3.4 :5901 ", "1.2.3.4", 5901); - doTest(" [1.2.3.4]:5902 ", "1.2.3.4", 5902); - doTest(" :5903 ", "localhost", 5903); - doTest(" ::4 ", "localhost", 4); - doTest(" [::1] ", "::1", 5900); - doTest(" 2001:1234::20:1 ", "2001:1234::20:1", 5900); - doTest(" [2001:1234::20:1] ", "2001:1234::20:1", 5900); - doTest(" [2001:1234::20:1]:5905 ", "2001:1234::20:1", 5905); - - return 0; + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } diff --git a/tests/unit/parameters.cxx b/tests/unit/parameters.cxx new file mode 100644 index 00000000..e120f988 --- /dev/null +++ b/tests/unit/parameters.cxx @@ -0,0 +1,839 @@ +/* Copyright 2025 Pierre Ossman <ossman@cendio.se> for Cendio AB + * + * This is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <stdexcept> + +#include <gtest/gtest.h> + +#include <core/Configuration.h> + +namespace core { + +// Generic comparison for our list parameters types that preserves +// the type (doesn't use any common base class) +template<typename IterL, typename IterR, + std::enable_if_t<std::is_member_function_pointer<decltype(&IterL::begin)>::value, bool> = true> +static bool operator==(const IterL& lhs, const IterR& rhs) +{ + if (std::distance(lhs.begin(), lhs.end()) != + std::distance(rhs.begin(), rhs.end())) + return false; + if (!std::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end())) + return false; + return true; +} + +static std::ostream& operator<<(std::ostream& os, + const core::EnumListEntry& e) +{ + return os << '"' << e.getValueStr() << '"'; +} + +} + +TEST(BoolParameter, values) +{ + core::BoolParameter bools("boolparam", "", false); + + bools.setParam(true); + EXPECT_TRUE(bools); + + bools.setParam(false); + EXPECT_FALSE(bools); +} + +TEST(BoolParameter, strings) +{ + core::BoolParameter strings("boolparam", "", false); + + strings.setParam("on"); + EXPECT_TRUE(strings); + + strings.setParam("off"); + EXPECT_FALSE(strings); + + strings.setParam("1"); + EXPECT_TRUE(strings); + + strings.setParam("0"); + EXPECT_FALSE(strings); + + strings.setParam("true"); + EXPECT_TRUE(strings); + + strings.setParam("false"); + EXPECT_FALSE(strings); + + strings.setParam("yes"); + EXPECT_TRUE(strings); + + strings.setParam("no"); + EXPECT_FALSE(strings); +} + +TEST(BoolParameter, validation) +{ + core::BoolParameter valid("boolparam", "", false); + + EXPECT_TRUE(valid.setParam("yes")); + EXPECT_TRUE(valid); + + EXPECT_FALSE(valid.setParam("foo")); + EXPECT_TRUE(valid); +} + +TEST(BoolParameter, encoding) +{ + core::BoolParameter encoding("boolparam", "", false); + + encoding.setParam(true); + EXPECT_EQ(encoding.getValueStr(), "on"); + + encoding.setParam(false); + EXPECT_EQ(encoding.getValueStr(), "off"); +} + +TEST(BoolParameter, default) +{ + core::BoolParameter def("boolparam", "", false); + + EXPECT_TRUE(def.isDefault()); + + def.setParam(true); + EXPECT_FALSE(def.isDefault()); + + def.setParam(false); + EXPECT_TRUE(def.isDefault()); +} + +TEST(BoolParameter, immutable) +{ + core::BoolParameter immutable("boolparam", "", false); + + immutable.setImmutable(); + immutable.setParam(true); + immutable.setParam("on"); + EXPECT_FALSE(immutable); +} + +TEST(IntParameter, values) +{ + core::IntParameter ints("intparam", "", 0); + + ints.setParam(123); + EXPECT_EQ(ints, 123); + + ints.setParam(-456); + EXPECT_EQ(ints, -456); +} + +TEST(IntParameter, strings) +{ + core::IntParameter strings("intparam", "", 0); + + strings.setParam("123"); + EXPECT_EQ(strings, 123); + + strings.setParam("-456"); + EXPECT_EQ(strings, -456); +} + +TEST(IntParameter, minmax) +{ + core::IntParameter bounds("intparam", "", 30, 20, 100); + + EXPECT_TRUE(bounds.setParam(57)); + EXPECT_EQ(bounds, 57); + + EXPECT_FALSE(bounds.setParam(123)); + EXPECT_EQ(bounds, 57); + + EXPECT_FALSE(bounds.setParam("123")); + EXPECT_EQ(bounds, 57); + + EXPECT_FALSE(bounds.setParam(-30)); + EXPECT_EQ(bounds, 57); + + EXPECT_FALSE(bounds.setParam("-30")); + EXPECT_EQ(bounds, 57); +} + +TEST(IntParameter, minmaxdefault) +{ + EXPECT_THROW({ + core::IntParameter defbounds("intparam", "", 10, 20, 100); + }, std::invalid_argument); +} + +TEST(IntParameter, validation) +{ + core::IntParameter valid("intparam", "", 0); + + EXPECT_TRUE(valid.setParam("123")); + EXPECT_EQ(valid, 123); + + EXPECT_FALSE(valid.setParam("foo")); + EXPECT_EQ(valid, 123); +} + +TEST(IntParameter, encoding) +{ + core::IntParameter encoding("intparam", "", 0); + + encoding.setParam(123); + EXPECT_EQ(encoding.getValueStr(), "123"); + + encoding.setParam(-456); + EXPECT_EQ(encoding.getValueStr(), "-456"); +} + +TEST(IntParameter, default) +{ + core::IntParameter def("intparam", "", 30); + + EXPECT_TRUE(def.isDefault()); + + def.setParam(123); + EXPECT_FALSE(def.isDefault()); + + def.setParam(30); + EXPECT_TRUE(def.isDefault()); +} + +TEST(IntParameter, immutable) +{ + core::IntParameter immutable("intparam", "", 0); + + immutable.setImmutable(); + immutable.setParam(123); + immutable.setParam("-456"); + EXPECT_EQ(immutable, 0); +} + +TEST(StringParameter, values) +{ + core::StringParameter strings("stringparam", "", ""); + + strings.setParam("foo"); + EXPECT_STREQ(strings, "foo"); + + strings.setParam("bar"); + EXPECT_STREQ(strings, "bar"); +} + +TEST(StringParameter, null) +{ + // NULL value + core::StringParameter null("stringparam", "", ""); + EXPECT_THROW({ + null.setParam(nullptr); + }, std::invalid_argument); + + // NULL default value + EXPECT_THROW({ + core::StringParameter defnull("stringparam", "", nullptr); + }, std::invalid_argument); +} + +TEST(StringParameter, encoding) +{ + core::StringParameter encoding("stringparam", "", ""); + + encoding.setParam("foo"); + EXPECT_EQ(encoding.getValueStr(), "foo"); + + encoding.setParam("bar"); + EXPECT_EQ(encoding.getValueStr(), "bar"); +} + +TEST(StringParameter, default) +{ + core::StringParameter def("stringparam", "", "test"); + + EXPECT_TRUE(def.isDefault()); + + def.setParam("foo"); + EXPECT_FALSE(def.isDefault()); + + def.setParam("test"); + EXPECT_TRUE(def.isDefault()); +} + +TEST(StringParameter, immutable) +{ + core::StringParameter immutable("stringparam", "", ""); + + immutable.setImmutable(); + immutable.setParam("foo"); + immutable.setParam("bar"); + EXPECT_STREQ(immutable, ""); +} + +TEST(EnumParameter, values) +{ + core::EnumParameter enums("enumparam", "", {"a", "b", "c"}, "a"); + + enums.setParam("b"); + EXPECT_FALSE(enums == "a"); + EXPECT_TRUE(enums == "b"); + EXPECT_FALSE(enums == "c"); + EXPECT_FALSE(enums == "foo"); + EXPECT_FALSE(enums != "b"); + EXPECT_TRUE(enums != "c"); + + enums.setParam("c"); + EXPECT_FALSE(enums == "a"); + EXPECT_FALSE(enums == "b"); + EXPECT_TRUE(enums == "c"); + EXPECT_FALSE(enums == "foo"); + EXPECT_TRUE(enums != "b"); + EXPECT_FALSE(enums != "c"); +} + +TEST(EnumParameter, caseinsensitive) +{ + core::EnumParameter casecmp("enumparam", "", {"a", "b", "c"}, "a"); + + casecmp.setParam("B"); + EXPECT_FALSE(casecmp == "a"); + EXPECT_TRUE(casecmp == "b"); + EXPECT_TRUE(casecmp == "B"); + EXPECT_FALSE(casecmp == "c"); + EXPECT_FALSE(casecmp != "b"); + EXPECT_TRUE(casecmp != "c"); +} + +TEST(EnumParameter, validation) +{ + core::EnumParameter valid("enumparam", "", {"a", "b", "c"}, "a"); + + EXPECT_TRUE(valid.setParam("b")); + EXPECT_EQ(valid.getValueStr(), "b"); + EXPECT_FALSE(valid.setParam("foo")); + EXPECT_EQ(valid.getValueStr(), "b"); + + // Valid default value + EXPECT_THROW({ + core::EnumParameter defvalid("enumparam", "", {"a", "b", "c"}, "d"); + }, std::invalid_argument); +} + +TEST(EnumParameter, null) +{ + // NULL value + core::EnumParameter null("enumparam", "", {"a", "b", "c"}, "a"); + EXPECT_THROW({ + null.setParam(nullptr); + }, std::invalid_argument); + + // NULL default value + EXPECT_THROW({ + core::EnumParameter defnull("enumparam", "", {""}, nullptr); + }, std::invalid_argument); + + // NULL enum value + EXPECT_THROW({ + core::EnumParameter nullenum("enumparam", "", {"a", nullptr, "b"}, "a"); + }, std::invalid_argument); +} + +TEST(EnumParameter, encoding) +{ + core::EnumParameter encoding("enumparam", "", {"a", "b", "c"}, "a"); + + encoding.setParam("b"); + EXPECT_EQ(encoding.getValueStr(), "b"); + + encoding.setParam("C"); + EXPECT_EQ(encoding.getValueStr(), "c"); +} + +TEST(EnumParameter, default) +{ + core::EnumParameter def("enumparam", "", {"a", "b", "c"}, "a"); + + EXPECT_TRUE(def.isDefault()); + + def.setParam("b"); + EXPECT_FALSE(def.isDefault()); + + def.setParam("A"); + EXPECT_TRUE(def.isDefault()); +} + +TEST(EnumParameter, immutable) +{ + core::EnumParameter immutable("enumparam", "", {"a", "b", "c"}, "a"); + + immutable.setImmutable(); + immutable.setParam("b"); + immutable.setParam("c"); + EXPECT_EQ(immutable.getValueStr(), "a"); +} + +TEST(BinaryParameter, values) +{ + std::vector<uint8_t> data; + + core::BinaryParameter binary("binaryparam", "", nullptr, 0); + + data = {1, 2, 3}; + binary.setParam(data.data(), data.size()); + ASSERT_EQ(binary.getData().size(), 3); + EXPECT_EQ(binary.getData()[0], 1); + EXPECT_EQ(binary.getData()[1], 2); + EXPECT_EQ(binary.getData()[2], 3); +} + +TEST(BinaryParameter, copy) +{ + std::vector<uint8_t> data; + + core::BinaryParameter copy("binaryparam", "", nullptr, 0); + + data = {1, 2, 3}; + copy.setParam(data.data(), data.size()); + ASSERT_EQ(copy.getData().size(), 3); + EXPECT_EQ(copy.getData()[0], 1); + EXPECT_EQ(copy.getData()[1], 2); + EXPECT_EQ(copy.getData()[2], 3); + + data[0] = 4; + EXPECT_EQ(copy.getData()[0], 1); +} + +TEST(BinaryParameter, strings) +{ + core::BinaryParameter strings("binaryparam", "", nullptr, 0); + + strings.setParam("010203"); + ASSERT_EQ(strings.getData().size(), 3); + EXPECT_EQ(strings.getData()[0], 1); + EXPECT_EQ(strings.getData()[1], 2); + EXPECT_EQ(strings.getData()[2], 3); + + strings.setParam("deadbeef"); + ASSERT_EQ(strings.getData().size(), 4); + EXPECT_EQ(strings.getData()[0], 0xde); + EXPECT_EQ(strings.getData()[1], 0xad); + EXPECT_EQ(strings.getData()[2], 0xbe); + EXPECT_EQ(strings.getData()[3], 0xef); +} + +TEST(BinaryParameter, validation) +{ + core::BinaryParameter valid("binaryparam", "", nullptr, 0); + + EXPECT_TRUE(valid.setParam("010203")); + ASSERT_EQ(valid.getData().size(), 3); + EXPECT_EQ(valid.getData()[0], 1); + EXPECT_EQ(valid.getData()[1], 2); + EXPECT_EQ(valid.getData()[2], 3); + + EXPECT_FALSE(valid.setParam("foo")); + ASSERT_EQ(valid.getData().size(), 3); + EXPECT_EQ(valid.getData()[0], 1); + EXPECT_EQ(valid.getData()[1], 2); + EXPECT_EQ(valid.getData()[2], 3); +} + +TEST(BinaryParameter, encoding) +{ + std::vector<uint8_t> data; + + core::BinaryParameter encoding("binaryparam", "", nullptr, 0); + + data = {1, 2, 3}; + encoding.setParam(data.data(), data.size()); + EXPECT_EQ(encoding.getValueStr(), "010203"); + + data = {0xde, 0xad, 0xbe, 0xef}; + encoding.setParam(data.data(), data.size()); + EXPECT_EQ(encoding.getValueStr(), "deadbeef"); +} + +TEST(BinaryParameter, default) +{ + std::vector<uint8_t> data; + + data = {1, 2, 3}; + core::BinaryParameter def("binaryparam", "", data.data(), data.size()); + + EXPECT_TRUE(def.isDefault()); + + data = {4, 5, 6}; + def.setParam(data.data(), data.size()); + EXPECT_FALSE(def.isDefault()); + + data = {1, 2, 3}; + def.setParam(data.data(), data.size()); + EXPECT_TRUE(def.isDefault()); +} + +TEST(BinaryParameter, immutable) +{ + std::vector<uint8_t> data; + + core::BinaryParameter immutable("binaryparam", "", nullptr, 0); + + immutable.setImmutable(); + data = {1, 2, 3}; + immutable.setParam(data.data(), data.size()); + immutable.setParam("deadbeef"); + EXPECT_EQ(immutable.getData().size(), 0); +} + +TEST(IntListParameter, values) +{ + std::list<int> data; + + core::IntListParameter list("listparam", "", {}); + + list.setParam({1, 2, 3, 4}); + data = {1, 2, 3, 4}; + EXPECT_EQ(list, data); +} + +TEST(IntListParameter, strings) +{ + std::list<int> data; + + core::IntListParameter strings("listparam", "", {}); + + strings.setParam("1,2,3,4"); + data = {1, 2, 3, 4}; + EXPECT_EQ(strings, data); + + strings.setParam("5 , 6 , 7,8"); + data = {5, 6, 7, 8}; + EXPECT_EQ(strings, data); + + strings.setParam("9,\n10,\t11,\t12"); + data = {9, 10, 11, 12}; + EXPECT_EQ(strings, data); + + strings.setParam(""); + data = {}; + EXPECT_EQ(strings, data); + + strings.setParam(" "); + data = {}; + EXPECT_EQ(strings, data); +} + +TEST(IntListParameter, minmax) +{ + std::list<int> data; + + core::IntListParameter bounds("listparam", "", {}, 20, 100); + + EXPECT_TRUE(bounds.setParam({57, 73})); + data = {57, 73}; + EXPECT_EQ(bounds, data); + + EXPECT_FALSE(bounds.setParam({57, 123})); + data = {57, 73}; + EXPECT_EQ(bounds, data); + + EXPECT_FALSE(bounds.setParam("57,123")); + data = {57, 73}; + EXPECT_EQ(bounds, data); + + EXPECT_FALSE(bounds.setParam({57, -30})); + data = {57, 73}; + EXPECT_EQ(bounds, data); + + EXPECT_FALSE(bounds.setParam("57,-30")); + data = {57, 73}; + EXPECT_EQ(bounds, data); +} + +TEST(IntListParameter, minmaxdefault) +{ + EXPECT_THROW({ + core::IntListParameter defbounds("listparam", "", {10}, 20, 100); + }, std::invalid_argument); +} + +TEST(IntListParameter, validation) +{ + std::list<int> data; + + core::IntListParameter valid("listparam", "", {}); + + EXPECT_TRUE(valid.setParam("1,2,3,4")); + data = {1, 2, 3, 4}; + EXPECT_EQ(valid, data); + + EXPECT_FALSE(valid.setParam("foo")); + data = {1, 2, 3, 4}; + EXPECT_EQ(valid, data); + + EXPECT_FALSE(valid.setParam("1,2,x,4")); + data = {1, 2, 3, 4}; + EXPECT_EQ(valid, data); +} + +TEST(IntListParameter, encoding) +{ + std::list<int> data; + + core::IntListParameter encoding("listparam", "", {}); + + encoding.setParam({1, 2, 3, 4}); + EXPECT_EQ(encoding.getValueStr(), "1,2,3,4"); +} + +TEST(IntListParameter, default) +{ + std::list<int> data; + + core::IntListParameter def("listparam", "", {1, 2, 3}); + + EXPECT_TRUE(def.isDefault()); + + def.setParam({4, 5, 6}); + EXPECT_FALSE(def.isDefault()); + + def.setParam({1, 2, 3}); + EXPECT_TRUE(def.isDefault()); +} + +TEST(IntListParameter, immutable) +{ + std::list<int> data; + + core::IntListParameter immutable("listparam", "", {}); + + immutable.setImmutable(); + immutable.setParam({1, 2, 3, 4}); + immutable.setParam("1,2,3,4"); + EXPECT_TRUE(immutable.begin() == immutable.end()); +} + +TEST(StringListParameter, values) +{ + std::list<std::string> data; + + core::StringListParameter list("listparam", "", {}); + + list.setParam({"1", "2", "3", "4"}); + data = {"1", "2", "3", "4"}; + EXPECT_EQ(list, data); +} + +TEST(StringListParameter, strings) +{ + std::list<std::string> data; + + core::StringListParameter strings("listparam", "", {}); + + strings.setParam("1,2,3,4"); + data = {"1", "2", "3", "4"}; + EXPECT_EQ(strings, data); + + strings.setParam("5 , 6 , 7,8"); + data = {"5", "6", "7", "8"}; + EXPECT_EQ(strings, data); + + strings.setParam("9,\n10,\t11,\t12"); + data = {"9", "10", "11", "12"}; + EXPECT_EQ(strings, data); + + strings.setParam(""); + data = {}; + EXPECT_EQ(strings, data); + + strings.setParam(" "); + data = {}; + EXPECT_EQ(strings, data); + + strings.setParam("a, , b"); + data = {"a", "", "b"}; + EXPECT_EQ(strings, data); +} + +TEST(StringListParameter, null) +{ + // NULL default value + EXPECT_THROW({ + core::StringListParameter defnull("enumparam", "", {nullptr}); + }, std::invalid_argument); +} + +TEST(StringListParameter, encoding) +{ + core::StringListParameter encoding("listparam", "", {}); + + encoding.setParam({"1", "2", "3", "4"}); + EXPECT_EQ(encoding.getValueStr(), "1,2,3,4"); +} + +TEST(StringListParameter, default) +{ + core::StringListParameter def("listparam", "", {"1", "2", "3"}); + + EXPECT_TRUE(def.isDefault()); + + def.setParam({"4", "5", "6"}); + EXPECT_FALSE(def.isDefault()); + + def.setParam({"1", "2", "3"}); + EXPECT_TRUE(def.isDefault()); +} + +TEST(StringListParameter, immutable) +{ + std::list<std::string> data; + + core::StringListParameter immutable("listparam", "", {"a", "b"}); + + immutable.setImmutable(); + immutable.setParam({"1", "2", "3", "4"}); + immutable.setParam("1,2,3,4"); + data = {"a", "b"}; + EXPECT_EQ(immutable, data); +} + +TEST(EnumListParameter, values) +{ + std::list<std::string> data; + + core::EnumListParameter list("listparam", "", {"a", "b", "c"}, {"a"}); + + list.setParam({"a", "b", "c"}); + data = {"a", "b", "c"}; + EXPECT_EQ(list, data); +} + +TEST(EnumListParameter, caseinsensitive) +{ + std::list<std::string> data; + + core::EnumListParameter casecmp("listparam", "", {"a", "b", "c"}, {"a"}); + + casecmp.setParam({"A", "B", "C"}); + data = {"a", "B", "c"}; + EXPECT_EQ(casecmp, data); +} + +TEST(EnumListParameter, strings) +{ + std::list<std::string> data; + + core::EnumListParameter strings("listparam", "", {"a", "b", "c"}, {"a"}); + + strings.setParam("a,b,c"); + data = {"a", "b", "c"}; + EXPECT_EQ(strings, data); + + strings.setParam("c , b , a,a"); + data = {"c", "b", "a", "a"}; + EXPECT_EQ(strings, data); + + strings.setParam("b,\na,\tc,\tb"); + data = {"b", "a", "c", "b"}; + EXPECT_EQ(strings, data); + + strings.setParam(""); + data = {}; + EXPECT_EQ(strings, data); + + strings.setParam(" "); + data = {}; + EXPECT_EQ(strings, data); +} + +TEST(EnumListParameter, validation) +{ + std::list<std::string> data; + + core::EnumListParameter valid("enumparam", "", {"a", "b", "c"}, {"a"}); + + EXPECT_TRUE(valid.setParam({"a", "b", "c"})); + data = {"a", "b", "c"}; + EXPECT_EQ(valid, data); + + EXPECT_FALSE(valid.setParam({"a", "foo", "c"})); + data = {"a", "b", "c"}; + EXPECT_EQ(valid, data); +} + +TEST(EnumListParameter, validdefault) +{ + EXPECT_THROW({ + core::EnumListParameter defvalid("enumparam", "", {"a", "b", "c"}, {"d"}); + }, std::invalid_argument); +} + +TEST(EnumListParameter, null) +{ + // NULL default value + EXPECT_THROW({ + core::EnumListParameter defnull("enumparam", "", {""}, {nullptr}); + }, std::invalid_argument); + + // NULL enum value + EXPECT_THROW({ + core::EnumListParameter nullenum("enumparam", "", {"a", nullptr, "b"}, {"a"}); + }, std::invalid_argument); +} + +TEST(EnumListParameter, encoding) +{ + core::EnumListParameter encoding("listparam", "", {"a", "b", "c"}, {"a"}); + + encoding.setParam({"a", "b", "C"}); + EXPECT_EQ(encoding.getValueStr(), "a,b,c"); +} + +TEST(EnumListParameter, default) +{ + core::EnumListParameter def("listparam", "", {"a", "b", "c"}, {"a"}); + + EXPECT_TRUE(def.isDefault()); + + def.setParam({"a", "b", "c"}); + EXPECT_FALSE(def.isDefault()); + + def.setParam("A"); + EXPECT_TRUE(def.isDefault()); +} + +TEST(EnumListParameter, immutable) +{ + std::list<std::string> data; + + core::EnumListParameter immutable("listparam", "", {"a", "b", "c"}, {"a"}); + + immutable.setImmutable(); + immutable.setParam({"a", "b", "c"}); + immutable.setParam("a,b,c"); + data = {"a"}; + EXPECT_EQ(immutable, data); +} + +int main(int argc, char** argv) +{ + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/tests/unit/pixelformat.cxx b/tests/unit/pixelformat.cxx index 54e68ccf..57d23cdf 100644 --- a/tests/unit/pixelformat.cxx +++ b/tests/unit/pixelformat.cxx @@ -1,4 +1,4 @@ -/* Copyright 2019 Pierre Ossman <ossman@cendio.se> for Cendio AB +/* Copyright 2019-2025 Pierre Ossman <ossman@cendio.se> for Cendio AB * * This is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -20,174 +20,233 @@ #include <config.h> #endif -#include <stdio.h> - +#include <list> #include <stdexcept> +#include <gtest/gtest.h> + #include <rfb/PixelFormat.h> -static void doTest(bool should_fail, int b, int d, bool e, bool t, - int rm, int gm, int bm, int rs, int gs, int bs) +struct Params { + int b; + int d; + bool e; + bool t; + int rm; + int gm; + int bm; + int rs; + int gs; + int bs; +}; + +static std::ostream& operator<<(std::ostream& os, const Params& p) { - rfb::PixelFormat* pf; - - printf("PixelFormat(%d, %d, %s, %s, %d, %d, %d, %d, %d, %d): ", - b, d, e ? "true" : "false", t ? "true": "false", - rm, gm, bm, rs, gs, bs); - - try { - pf = new rfb::PixelFormat(b, d, e, t, rm, gm, bm, rs, gs, bs); - } catch(std::exception&) { - if (should_fail) - printf("OK"); - else - printf("FAILED"); - printf("\n"); - fflush(stdout); - return; - } - - delete pf; - - if (should_fail) - printf("FAILED"); - else - printf("OK"); - printf("\n"); - fflush(stdout); + return os << p.b << ", " << p.d << ", " << + (p.e ? "true" : "false") << " " << + (p.t ? "true" : "false") << ", " << + p.rm << ", " << p.gm << ", " << p.bm << ", " + << p.rs << ", " << p.gs << ", " << p.bs; } -static void do888Test(bool expected, int b, int d, bool e, bool t, - int rm, int gm, int bm, int rs, int gs, int bs) +typedef testing::TestWithParam<Params> PixelFormatValid; + +TEST_P(PixelFormatValid, constructor) { - rfb::PixelFormat* pf; + Params params; + rfb::PixelFormat* pf; + + params = GetParam(); + pf = nullptr; + + EXPECT_NO_THROW({ + pf = new rfb::PixelFormat(params.b, params.d, params.e, params.t, + params.rm, params.gm, params.bm, + params.rs, params.gs, params.bs); + }); - printf("PixelFormat(%d, %d, %s, %s, %d, %d, %d, %d, %d, %d): ", - b, d, e ? "true" : "false", t ? "true": "false", - rm, gm, bm, rs, gs, bs); + delete pf; +} + +typedef testing::TestWithParam<Params> PixelFormatInvalid; + +TEST_P(PixelFormatInvalid, constructor) +{ + Params params; + rfb::PixelFormat* pf; - pf = new rfb::PixelFormat(b, d, e, t, rm, gm, bm, rs, gs, bs); + params = GetParam(); + pf = nullptr; - if (pf->is888() == expected) - printf("OK"); - else - printf("FAILED"); - printf("\n"); - fflush(stdout); + EXPECT_THROW({ + pf = new rfb::PixelFormat(params.b, params.d, params.e, params.t, + params.rm, params.gm, params.bm, + params.rs, params.gs, params.bs); + }, std::invalid_argument); - delete pf; + delete pf; } -static void sanityTests() +typedef testing::TestWithParam<Params> PixelFormatIs888; + +TEST_P(PixelFormatIs888, constructor) { - printf("Sanity checks:\n\n"); + Params params; + rfb::PixelFormat* pf; + + params = GetParam(); + pf = new rfb::PixelFormat(params.b, params.d, params.e, params.t, + params.rm, params.gm, params.bm, + params.rs, params.gs, params.bs); + EXPECT_TRUE(pf->is888()); - /* Normal true color formats */ + delete pf; +} - doTest(false, 32, 24, false, true, 255, 255, 255, 0, 8, 16); - doTest(false, 32, 24, false, true, 255, 255, 255, 24, 16, 8); +typedef testing::TestWithParam<Params> PixelFormatNot888; - doTest(false, 16, 16, false, true, 15, 31, 15, 0, 5, 11); +TEST_P(PixelFormatNot888, constructor) +{ + Params params; + rfb::PixelFormat* pf; - doTest(false, 8, 8, false, true, 3, 7, 3, 0, 2, 5); + params = GetParam(); + pf = new rfb::PixelFormat(params.b, params.d, params.e, params.t, + params.rm, params.gm, params.bm, + params.rs, params.gs, params.bs); + EXPECT_FALSE(pf->is888()); - /* Excessive bpp */ + delete pf; +} - doTest(false, 32, 16, false, true, 15, 31, 15, 0, 5, 11); +static std::list<Params> validFormats() +{ + std::list<Params> params; - doTest(false, 16, 16, false, true, 15, 31, 15, 0, 5, 11); + /* Normal true color formats */ - doTest(false, 32, 8, false, true, 3, 7, 3, 0, 2, 5); + params.push_back(Params{32, 24, false, true, 255, 255, 255, 0, 8, 16}); + params.push_back(Params{32, 24, false, true, 255, 255, 255, 24, 16, 8}); - doTest(false, 16, 8, false, true, 3, 7, 3, 0, 2, 5); + params.push_back(Params{16, 16, false, true, 15, 31, 15, 0, 5, 11}); - /* Colour map */ + params.push_back(Params{8, 8, false, true, 3, 7, 3, 0, 2, 5}); - doTest(false, 8, 8, false, false, 0, 0, 0, 0, 0, 0); + /* Excessive bpp */ - /* Invalid bpp */ + params.push_back(Params{32, 16, false, true, 15, 31, 15, 0, 5, 11}); - doTest(true, 64, 24, false, true, 255, 255, 255, 0, 8, 16); + params.push_back(Params{16, 16, false, true, 15, 31, 15, 0, 5, 11}); - doTest(true, 18, 16, false, true, 15, 31, 15, 0, 5, 11); + params.push_back(Params{32, 8, false, true, 3, 7, 3, 0, 2, 5}); - doTest(true, 3, 3, false, true, 1, 1, 1, 0, 1, 2); + params.push_back(Params{16, 8, false, true, 3, 7, 3, 0, 2, 5}); - /* Invalid depth */ + /* Colour map */ - doTest(true, 16, 24, false, true, 15, 31, 15, 0, 5, 11); + params.push_back(Params{8, 8, false, false, 0, 0, 0, 0, 0, 0}); - doTest(true, 8, 24, false, true, 3, 7, 3, 0, 2, 5); - doTest(true, 8, 16, false, true, 3, 7, 3, 0, 2, 5); + return params; +} - doTest(true, 32, 24, false, false, 0, 0, 0, 0, 0, 0); +INSTANTIATE_TEST_SUITE_P(, PixelFormatValid, testing::ValuesIn(validFormats())); - /* Invalid max values */ +static std::list<Params> invalidFormats() +{ + std::list<Params> params; - doTest(true, 32, 24, false, true, 254, 255, 255, 0, 8, 16); - doTest(true, 32, 24, false, true, 255, 253, 255, 0, 8, 16); - doTest(true, 32, 24, false, true, 255, 255, 252, 0, 8, 16); + params.push_back(Params{64, 24, false, true, 255, 255, 255, 0, 8, 16}); - doTest(true, 32, 24, false, true, 511, 127, 127, 0, 16, 20); - doTest(true, 32, 24, false, true, 127, 511, 127, 0, 4, 20); - doTest(true, 32, 24, false, true, 127, 127, 511, 0, 4, 8); + params.push_back(Params{18, 16, false, true, 15, 31, 15, 0, 5, 11}); - /* Insufficient depth */ + params.push_back(Params{3, 3, false, true, 1, 1, 1, 0, 1, 2}); - doTest(true, 32, 16, false, true, 255, 255, 255, 0, 8, 16); + /* Invalid depth */ - /* Invalid shift values */ + params.push_back(Params{16, 24, false, true, 15, 31, 15, 0, 5, 11}); - doTest(true, 32, 24, false, true, 255, 255, 255, 25, 8, 16); - doTest(true, 32, 24, false, true, 255, 255, 255, 0, 25, 16); - doTest(true, 32, 24, false, true, 255, 255, 255, 0, 8, 25); + params.push_back(Params{8, 24, false, true, 3, 7, 3, 0, 2, 5}); + params.push_back(Params{8, 16, false, true, 3, 7, 3, 0, 2, 5}); - /* Overlapping channels */ + params.push_back(Params{32, 24, false, false, 0, 0, 0, 0, 0, 0}); - doTest(true, 32, 24, false, true, 255, 255, 255, 0, 7, 16); - doTest(true, 32, 24, false, true, 255, 255, 255, 0, 8, 15); - doTest(true, 32, 24, false, true, 255, 255, 255, 0, 16, 7); + /* Invalid max values */ - printf("\n"); + params.push_back(Params{32, 24, false, true, 254, 255, 255, 0, 8, 16}); + params.push_back(Params{32, 24, false, true, 255, 253, 255, 0, 8, 16}); + params.push_back(Params{32, 24, false, true, 255, 255, 252, 0, 8, 16}); + + params.push_back(Params{32, 24, false, true, 511, 127, 127, 0, 16, 20}); + params.push_back(Params{32, 24, false, true, 127, 511, 127, 0, 4, 20}); + params.push_back(Params{32, 24, false, true, 127, 127, 511, 0, 4, 8}); + + /* Insufficient depth */ + + params.push_back(Params{32, 16, false, true, 255, 255, 255, 0, 8, 16}); + + /* Invalid shift values */ + + params.push_back(Params{32, 24, false, true, 255, 255, 255, 25, 8, 16}); + params.push_back(Params{32, 24, false, true, 255, 255, 255, 0, 25, 16}); + params.push_back(Params{32, 24, false, true, 255, 255, 255, 0, 8, 25}); + + /* Overlapping channels */ + + params.push_back(Params{32, 24, false, true, 255, 255, 255, 0, 7, 16}); + params.push_back(Params{32, 24, false, true, 255, 255, 255, 0, 8, 15}); + params.push_back(Params{32, 24, false, true, 255, 255, 255, 0, 16, 7}); + + return params; } -void is888Tests() +INSTANTIATE_TEST_SUITE_P(, PixelFormatInvalid, testing::ValuesIn(invalidFormats())); + +static std::list<Params> is888Formats() { - printf("Simple format detection:\n\n"); + std::list<Params> params; + + /* Positive cases */ + + params.push_back(Params{32, 24, false, true, 255, 255, 255, 0, 8, 16}); + params.push_back(Params{32, 24, false, true, 255, 255, 255, 24, 16, 8}); + params.push_back(Params{32, 24, false, true, 255, 255, 255, 24, 8, 0}); + + return params; +} - /* Positive cases */ +INSTANTIATE_TEST_SUITE_P(, PixelFormatIs888, testing::ValuesIn(is888Formats())); - do888Test(true, 32, 24, false, true, 255, 255, 255, 0, 8, 16); - do888Test(true, 32, 24, false, true, 255, 255, 255, 24, 16, 8); - do888Test(true, 32, 24, false, true, 255, 255, 255, 24, 8, 0); +static std::list<Params> not888Formats() +{ + std::list<Params> params; - /* Low depth */ + /* Low depth */ - do888Test(false, 32, 16, false, true, 15, 31, 15, 0, 8, 16); - do888Test(false, 32, 8, false, true, 3, 7, 3, 0, 8, 16); + params.push_back(Params{32, 16, false, true, 15, 31, 15, 0, 8, 16}); + params.push_back(Params{32, 8, false, true, 3, 7, 3, 0, 8, 16}); - /* Low bpp and depth */ + /* Low bpp and depth */ - do888Test(false, 16, 16, false, true, 15, 31, 15, 0, 5, 11); - do888Test(false, 8, 8, false, true, 3, 7, 3, 0, 2, 5); + params.push_back(Params{16, 16, false, true, 15, 31, 15, 0, 5, 11}); + params.push_back(Params{8, 8, false, true, 3, 7, 3, 0, 2, 5}); - /* Colour map */ + /* Colour map */ - do888Test(false, 8, 8, false, false, 0, 0, 0, 0, 0, 0); + params.push_back(Params{8, 8, false, false, 0, 0, 0, 0, 0, 0}); - /* Odd shifts */ + /* Odd shifts */ - do888Test(false, 32, 24, false, true, 255, 255, 255, 0, 8, 18); - do888Test(false, 32, 24, false, true, 255, 255, 255, 0, 11, 24); - do888Test(false, 32, 24, false, true, 255, 255, 255, 4, 16, 24); + params.push_back(Params{32, 24, false, true, 255, 255, 255, 0, 8, 18}); + params.push_back(Params{32, 24, false, true, 255, 255, 255, 0, 11, 24}); + params.push_back(Params{32, 24, false, true, 255, 255, 255, 4, 16, 24}); - printf("\n"); + return params; } -int main(int /*argc*/, char** /*argv*/) -{ - sanityTests(); - is888Tests(); +INSTANTIATE_TEST_SUITE_P(, PixelFormatNot888, testing::ValuesIn(not888Formats())); - return 0; +int main(int argc, char** argv) +{ + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } diff --git a/tests/unit/shortcuthandler.cxx b/tests/unit/shortcuthandler.cxx new file mode 100644 index 00000000..aa005155 --- /dev/null +++ b/tests/unit/shortcuthandler.cxx @@ -0,0 +1,607 @@ +/* Copyright 2021-2025 Pierre Ossman for Cendio AB + * + * This is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this software; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, + * USA. + */ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <gtest/gtest.h> + +#define XK_LATIN1 +#define XK_MISCELLANY +#include <rfb/keysymdef.h> + +#include "ShortcutHandler.h" + +TEST(ShortcutHandler, noModifiers) +{ + ShortcutHandler handler; + + handler.setModifiers(0); + + EXPECT_EQ(handler.handleKeyPress(1, XK_a), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(4, XK_Hyper_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(5, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(4), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(5), ShortcutHandler::KeyNormal); +} + +TEST(ShortcutHandler, singleArmed) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyUnarm); +} + +TEST(ShortcutHandler, singleDualArmed) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Control_R), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyUnarm); +} + +TEST(ShortcutHandler, singleShortcut) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyIgnore); +} + +TEST(ShortcutHandler, singleRightShortcut) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_R), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyIgnore); +} + +TEST(ShortcutHandler, singleDualShortcut) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Control_R), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyIgnore); +} + +TEST(ShortcutHandler, singleShortcutReordered) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyShortcut); +} + +TEST(ShortcutHandler, singleDualShortcutReordered) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyPress(2, XK_Control_R), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyIgnore); +} + +TEST(ShortcutHandler, singleShortcutRepeated) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyIgnore); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyIgnore); +} + +TEST(ShortcutHandler, singleShortcutMultipleKeys) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyPress(3, XK_b), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyPress(4, XK_c), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(4), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyIgnore); +} + +TEST(ShortcutHandler, singleWedgeNormal) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control); + + EXPECT_EQ(handler.handleKeyPress(1, XK_b), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_a), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyNormal); +} + +TEST(ShortcutHandler, singleWedgeModifier) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_a), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyNormal); +} + +TEST(ShortcutHandler, singleWedgeModifierArmed) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_a), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyNormal); +} + +TEST(ShortcutHandler, singleWedgeModifierFiring) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyPress(3, XK_Shift_L), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyIgnore); +} + +TEST(ShortcutHandler, singleUnwedge) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control); + + handler.handleKeyPress(1, XK_Shift_L); + handler.handleKeyPress(2, XK_Control_L); + handler.handleKeyRelease(1); + handler.handleKeyRelease(2); + + EXPECT_EQ(handler.handleKeyPress(2, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyIgnore); +} + +TEST(ShortcutHandler, multiArmed) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control | + ShortcutHandler::Shift | + ShortcutHandler::Alt); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyUnarm); +} + +TEST(ShortcutHandler, multiRearmed) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control | + ShortcutHandler::Shift | + ShortcutHandler::Alt); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyUnarm); +} + +TEST(ShortcutHandler, multiFailedArm) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control | + ShortcutHandler::Shift | + ShortcutHandler::Alt); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyNormal); +} + +TEST(ShortcutHandler, multiDualArmed) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control | + ShortcutHandler::Shift | + ShortcutHandler::Alt); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Alt_R), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(4, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(4), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyUnarm); +} + +TEST(ShortcutHandler, multiShortcut) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control | + ShortcutHandler::Shift | + ShortcutHandler::Alt); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(4, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(4), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyIgnore); +} + +TEST(ShortcutHandler, multiRightShortcut) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control | + ShortcutHandler::Shift | + ShortcutHandler::Alt); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_R), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Alt_R), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Shift_R), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(4, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(4), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyIgnore); +} + +TEST(ShortcutHandler, multiDualShortcut) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control | + ShortcutHandler::Shift | + ShortcutHandler::Alt); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Control_R), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(4, XK_Alt_R), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(5, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(6, XK_Shift_R), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(7, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(7), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(6), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(5), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(4), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyIgnore); +} + +TEST(ShortcutHandler, multiShortcutReordered) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control | + ShortcutHandler::Shift | + ShortcutHandler::Alt); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(4, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(4), ShortcutHandler::KeyShortcut); +} + +TEST(ShortcutHandler, multiDualShortcutReordered) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control | + ShortcutHandler::Shift | + ShortcutHandler::Alt); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(5, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(7, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyPress(2, XK_Control_R), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyPress(4, XK_Alt_R), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyPress(6, XK_Shift_R), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(6), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(4), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(7), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(5), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyIgnore); +} + +TEST(ShortcutHandler, multiShortcutRepeated) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control | + ShortcutHandler::Shift | + ShortcutHandler::Alt); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(4, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(4), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyIgnore); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(4, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(4), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyIgnore); +} + +TEST(ShortcutHandler, multiShortcutMultipleKeys) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control | + ShortcutHandler::Shift | + ShortcutHandler::Alt); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(4, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyPress(5, XK_b), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(4), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(5), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyPress(6, XK_c), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(6), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyIgnore); +} + +TEST(ShortcutHandler, multiWedgeNormal) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control | + ShortcutHandler::Shift | + ShortcutHandler::Alt); + + EXPECT_EQ(handler.handleKeyPress(1, XK_b), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(4, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(5, XK_a), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(5), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(4), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyNormal); +} + +TEST(ShortcutHandler, multiWedgeModifier) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control | + ShortcutHandler::Shift | + ShortcutHandler::Alt); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Super_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(4, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(5, XK_a), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(5), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(4), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyNormal); +} + +TEST(ShortcutHandler, multiWedgeArming) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control | + ShortcutHandler::Shift | + ShortcutHandler::Alt); + + EXPECT_EQ(handler.handleKeyPress(2, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(1, XK_b), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(4, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(5, XK_a), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(5), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(4), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyNormal); +} + +TEST(ShortcutHandler, multiWedgeModifierArming) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control | + ShortcutHandler::Shift | + ShortcutHandler::Alt); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(4, XK_Super_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(4), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyNormal); +} + +TEST(ShortcutHandler, multiWedgeModifierArmed) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control | + ShortcutHandler::Shift | + ShortcutHandler::Alt); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(4, XK_Super_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(4), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyNormal); +} + +TEST(ShortcutHandler, multiWedgeModifierFiring) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control | + ShortcutHandler::Shift | + ShortcutHandler::Alt); + + EXPECT_EQ(handler.handleKeyPress(1, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(2, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(4, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyPress(5, XK_Super_L), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(5), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(4), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(1), ShortcutHandler::KeyIgnore); +} + +TEST(ShortcutHandler, multiUnwedge) +{ + ShortcutHandler handler; + + handler.setModifiers(ShortcutHandler::Control | + ShortcutHandler::Shift | + ShortcutHandler::Alt); + + handler.handleKeyPress(1, XK_Super_L); + handler.handleKeyPress(2, XK_Control_L); + handler.handleKeyPress(3, XK_Alt_L); + handler.handleKeyPress(4, XK_Shift_L); + handler.handleKeyRelease(1); + handler.handleKeyRelease(2); + handler.handleKeyRelease(3); + handler.handleKeyRelease(4); + + EXPECT_EQ(handler.handleKeyPress(2, XK_Control_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(3, XK_Alt_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(4, XK_Shift_L), ShortcutHandler::KeyNormal); + EXPECT_EQ(handler.handleKeyPress(5, XK_a), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(5), ShortcutHandler::KeyShortcut); + EXPECT_EQ(handler.handleKeyRelease(4), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(3), ShortcutHandler::KeyIgnore); + EXPECT_EQ(handler.handleKeyRelease(2), ShortcutHandler::KeyIgnore); +} + +int main(int argc, char** argv) +{ + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/tests/unit/unicode.cxx b/tests/unit/unicode.cxx index 71815042..00e09c15 100644 --- a/tests/unit/unicode.cxx +++ b/tests/unit/unicode.cxx @@ -1,4 +1,4 @@ -/* Copyright 2020 Pierre Ossman <ossman@cendio.se> for Cendio AB +/* Copyright 2020-2025 Pierre Ossman <ossman@cendio.se> for Cendio AB * * This is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -20,11 +20,12 @@ #include <config.h> #endif -#include <stdio.h> #include <string.h> #include <wchar.h> -#include <rfb/util.h> +#include <gtest/gtest.h> + +#include <core/string.h> struct _ucs4utf8 { unsigned ucs4; @@ -112,149 +113,138 @@ const wchar_t *invalidutf16[] = { #define ARRAY_SIZE(a) (sizeof(a)/sizeof(*a)) -int main(int /*argc*/, char** /*argv*/) +TEST(Unicode, ucs4ToUTF8) { - int failures; - size_t i; + size_t i; + for (i = 0;i < ARRAY_SIZE(ucs4utf8);i++) { + size_t len; + char utf8[5]; + + /* Expected failure? */ + if (ucs4utf8[i].ucs4 == 0xfffd) + continue; + + len = core::ucs4ToUTF8(ucs4utf8[i].ucs4, utf8); + EXPECT_STREQ(utf8, ucs4utf8[i].utf8); + EXPECT_EQ(len, strlen(utf8)); + } +} +TEST(Unicode, utf8ToUCS4) +{ + size_t i; + for (i = 0;i < ARRAY_SIZE(ucs4utf8);i++) { + size_t len; unsigned ucs4; - char utf8[5]; + + /* Expected failure? */ + if (strcmp(ucs4utf8[i].utf8, "\xef\xbf\xbd") == 0) + continue; + + len = core::utf8ToUCS4(ucs4utf8[i].utf8, strlen(ucs4utf8[i].utf8), &ucs4); + EXPECT_EQ(ucs4, ucs4utf8[i].ucs4); + EXPECT_EQ(len, strlen(ucs4utf8[i].utf8)); + } +} + +TEST(Unicode, ucs4ToUTF16) +{ + size_t i; + for (i = 0;i < ARRAY_SIZE(ucs4utf16);i++) { + size_t len; wchar_t utf16[3]; - std::string out; - std::wstring wout; + + /* Expected failure? */ + if (ucs4utf16[i].ucs4 == 0xfffd) + continue; + + len = core::ucs4ToUTF16(ucs4utf16[i].ucs4, utf16); + EXPECT_STREQ(utf16, ucs4utf16[i].utf16); + EXPECT_EQ(len, wcslen(utf16)); + } +} + +TEST(Unicode, utf16ToUCS4) +{ + size_t i; + for (i = 0;i < ARRAY_SIZE(ucs4utf16);i++) { size_t len; + unsigned ucs4; - failures = 0; - - for (i = 0;i < ARRAY_SIZE(ucs4utf8);i++) { - /* Expected failure? */ - if (ucs4utf8[i].ucs4 == 0xfffd) - continue; - - len = rfb::ucs4ToUTF8(ucs4utf8[i].ucs4, utf8); - if ((len != strlen(utf8)) || - (strcmp(utf8, ucs4utf8[i].utf8) != 0)) { - printf("FAILED: ucs4ToUTF8() #%d\n", (int)i+1); - failures++; - } - } - - for (i = 0;i < ARRAY_SIZE(ucs4utf8);i++) { - /* Expected failure? */ - if (strcmp(ucs4utf8[i].utf8, "\xef\xbf\xbd") == 0) - continue; - - len = rfb::utf8ToUCS4(ucs4utf8[i].utf8, strlen(ucs4utf8[i].utf8), &ucs4); - if ((len != strlen(ucs4utf8[i].utf8)) || - (ucs4 != ucs4utf8[i].ucs4)) { - printf("FAILED: utf8ToUCS4() #%d\n", (int)i+1); - failures++; - } - } - - for (i = 0;i < ARRAY_SIZE(ucs4utf16);i++) { - /* Expected failure? */ - if (ucs4utf16[i].ucs4 == 0xfffd) - continue; - - len = rfb::ucs4ToUTF16(ucs4utf16[i].ucs4, utf16); - if ((len != wcslen(utf16)) || - (wcscmp(utf16, ucs4utf16[i].utf16) != 0)) { - printf("FAILED: ucs4ToUTF16() #%d\n", (int)i+1); - failures++; - } - } - - for (i = 0;i < ARRAY_SIZE(ucs4utf16);i++) { - /* Expected failure? */ - if (wcscmp(ucs4utf16[i].utf16, L"\xfffd") == 0) - continue; - - len = rfb::utf16ToUCS4(ucs4utf16[i].utf16, wcslen(ucs4utf16[i].utf16), &ucs4); - if ((len != wcslen(ucs4utf16[i].utf16)) || - (ucs4 != ucs4utf16[i].ucs4)) { - printf("FAILED: utf16ToUCS4() #%d\n", (int)i+1); - failures++; - } - } - - for (i = 0;i < ARRAY_SIZE(latin1utf8);i++) { - /* Expected failure? */ - if (strchr(latin1utf8[i].latin1, '?') != nullptr) - continue; - - out = rfb::latin1ToUTF8(latin1utf8[i].latin1); - if (out != latin1utf8[i].utf8) { - printf("FAILED: latin1ToUTF8() #%d\n", (int)i+1); - failures++; - } - } - - for (i = 0;i < ARRAY_SIZE(latin1utf8);i++) { - out = rfb::utf8ToLatin1(latin1utf8[i].utf8); - if (out != latin1utf8[i].latin1) { - printf("FAILED: utf8ToLatin1() #%d\n", (int)i+1); - failures++; - } - } - - for (i = 0;i < ARRAY_SIZE(utf8utf16);i++) { - /* Expected failure? */ - if (wcscmp(utf8utf16[i].utf16, L"\xfffd") == 0) - continue; - - out = rfb::utf16ToUTF8(utf8utf16[i].utf16); - if (out != utf8utf16[i].utf8) { - printf("FAILED: utf16ToUTF8() #%d\n", (int)i+1); - failures++; - } - } - - for (i = 0;i < ARRAY_SIZE(utf8utf16);i++) { - /* Expected failure? */ - if (strstr(utf8utf16[i].utf8, "\xef\xbf\xbd") != nullptr) - continue; - - wout = rfb::utf8ToUTF16(utf8utf16[i].utf8); - if (wout != utf8utf16[i].utf16) { - printf("FAILED: utf8ToUTF16() #%d\n", (int)i+1); - failures++; - } - } - - for (i = 0;i < ARRAY_SIZE(validutf8);i++) { - if (!rfb::isValidUTF8(validutf8[i])) { - printf("FAILED: isValidUTF8() #%d\n", (int)i+1); - failures++; - } - } - - for (i = 0;i < ARRAY_SIZE(invalidutf8);i++) { - if (rfb::isValidUTF8(invalidutf8[i])) { - printf("FAILED: ! isValidUTF8() #%d\n", (int)i+1); - failures++; - } - } - - for (i = 0;i < ARRAY_SIZE(validutf16);i++) { - if (!rfb::isValidUTF16(validutf16[i])) { - printf("FAILED: isValidUTF16() #%d\n", (int)i+1); - failures++; - } - } - - for (i = 0;i < ARRAY_SIZE(invalidutf16);i++) { - if (rfb::isValidUTF16(invalidutf16[i])) { - printf("FAILED: ! isValidUTF16() #%d\n", (int)i+1); - failures++; - } - } - - if (failures == 0) { - printf("OK\n"); - } else { - printf("FAIL: %d failures\n", failures); - } - - return 0; + /* Expected failure? */ + if (wcscmp(ucs4utf16[i].utf16, L"\xfffd") == 0) + continue; + + len = core::utf16ToUCS4(ucs4utf16[i].utf16, wcslen(ucs4utf16[i].utf16), &ucs4); + EXPECT_EQ(ucs4, ucs4utf16[i].ucs4); + EXPECT_EQ(len, wcslen(ucs4utf16[i].utf16)); + } +} + +TEST(Unicode, latin1ToUTF8) +{ + size_t i; + + for (i = 0; i < ARRAY_SIZE(latin1utf8); i++) { + /* Expected failure? */ + if (strchr(latin1utf8[i].latin1, '?') != nullptr) + continue; + + EXPECT_EQ(core::latin1ToUTF8(latin1utf8[i].latin1), latin1utf8[i].utf8); + } +} + +TEST(Unicode, utf8ToLatin1) +{ + size_t i; + for (i = 0; i < ARRAY_SIZE(latin1utf8); i++) + EXPECT_EQ(core::utf8ToLatin1(latin1utf8[i].utf8), latin1utf8[i].latin1); +} + +TEST(Unicode, utf16ToUTF8) +{ + size_t i; + for (i = 0; i < ARRAY_SIZE(utf8utf16); i++) { + /* Expected failure? */ + if (wcscmp(utf8utf16[i].utf16, L"\xfffd") == 0) + continue; + + EXPECT_EQ(core::utf16ToUTF8(utf8utf16[i].utf16), utf8utf16[i].utf8); + } +} + +TEST(Unicode, utf8ToUTF16) +{ + size_t i; + for (i = 0; i < ARRAY_SIZE(utf8utf16); i++) { + /* Expected failure? */ + if (strstr(utf8utf16[i].utf8, "\xef\xbf\xbd") != nullptr) + continue; + + EXPECT_EQ(core::utf8ToUTF16(utf8utf16[i].utf8), utf8utf16[i].utf16); + } +} + +TEST(Unicode, isValidUTF8) +{ + size_t i; + for (i = 0; i < ARRAY_SIZE(validutf8); i++) + EXPECT_TRUE(core::isValidUTF8(validutf8[i])); + for (i = 0; i < ARRAY_SIZE(invalidutf8); i++) + EXPECT_FALSE(core::isValidUTF8(invalidutf8[i])); +} + +TEST(Unicode, isValidUTF16) +{ + size_t i; + for (i = 0; i < ARRAY_SIZE(validutf16); i++) + EXPECT_TRUE(core::isValidUTF16(validutf16[i])); + for (i = 0; i < ARRAY_SIZE(invalidutf16); i++) + EXPECT_FALSE(core::isValidUTF16(invalidutf16[i])); +} + +int main(int argc, char** argv) +{ + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } |