openclaw/deskflow
1
0
Fork 0
Code Issues Pull Requests Actions 17 Packages Projects Releases Wiki Activity

chore: remove unused tests

Browse Source 
Remove Unused Mocks
Remove remaing uses of TEST_ENV and its guarded items
This commit is contained in:
sithlord48
2025-04-28 18:05:19 -04:00
committed by Nick Bolton
parent d8b4fab9a3
commit 8f53b88bb6
17 changed files with 0 additions and 1664 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
src/lib/client/ServerProxy.h
View File

@ -51,13 +51,6 @@ public:
//@}
#ifdef TEST_ENV
void handleDataForTest()
{
handleData(Event(), nullptr);
}
#endif
protected:
enum EResult
{

19
src/lib/platform/XWindowsKeyState.h
View File

@ -129,9 +129,6 @@ private:
bool m_lock;
};
#ifdef TEST_ENV
public: // yuck
#endif
using KeyModifierMaskList = std::vector<KeyModifierMask>;
private:
@ -159,20 +156,4 @@ private:
// autorepeat state
XKeyboardState m_keyboardState;
#ifdef TEST_ENV
public:
int32_t group() const
{
return m_group;
}
void group(const int32_t &group)
{
m_group = group;
}
KeyModifierMaskList modifierFromX() const
{
return m_modifierFromX;
}
#endif
};

6
src/lib/server/InputFilter.h
View File

@ -359,12 +359,6 @@ public:
InputFilter(const InputFilter &);
virtual ~InputFilter();
#ifdef TEST_ENV
InputFilter() : m_primaryClient(nullptr)
{
}
#endif
InputFilter &operator=(const InputFilter &);
// add rule, adopting the condition and the actions

6
src/lib/server/PrimaryClient.h
View File

@ -29,12 +29,6 @@ public:
PrimaryClient(const std::string &name, deskflow::Screen *screen);
~PrimaryClient() override = default;
#ifdef TEST_ENV
PrimaryClient() : BaseClientProxy("")
{
}
#endif
//! @name manipulators
//@{

27
src/test/mock/deskflow/MockScreen.h
View File

@ -1,27 +0,0 @@
/*
* Deskflow -- mouse and keyboard sharing utility
* SPDX-FileCopyrightText: (C) 2013 - 2016 Symless Ltd.
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/
#pragma once
#define TEST_ENV
#include "deskflow/Screen.h"
#include <gmock/gmock.h>
class MockScreen : public deskflow::Screen
{
public:
MockScreen() : deskflow::Screen()
{
}
MOCK_METHOD(void, disable, (), (override));
MOCK_METHOD(void, getShape, (int32_t &, int32_t &, int32_t &, int32_t &), (const, override));
MOCK_METHOD(void, getCursorPos, (int32_t &, int32_t &), (const, override));
MOCK_METHOD(void, resetOptions, (), (override));
MOCK_METHOD(void, setOptions, (const OptionsList &), (override));
MOCK_METHOD(void, enable, (), (override));
};

23
src/test/mock/server/MockConfig.h
View File

@ -1,23 +0,0 @@
/*
* Deskflow -- mouse and keyboard sharing utility
* SPDX-FileCopyrightText: (C) 2013 - 2016 Symless Ltd.
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/
#pragma once
#define TEST_ENV
#include "server/Config.h"
#include <gmock/gmock.h>
class MockConfig : public Config
{
public:
MockConfig() : Config()
{
}
MOCK_METHOD(InputFilter *, getInputFilter, (), (override));
MOCK_METHOD(bool, isScreen, (const std::string &), (const, override));
};

19
src/test/mock/server/MockInputFilter.h
View File

@ -1,19 +0,0 @@
/*
* Deskflow -- mouse and keyboard sharing utility
* SPDX-FileCopyrightText: (C) 2013 - 2016 Symless Ltd.
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/
#pragma once
#define TEST_ENV
#include "server/InputFilter.h"
#include <gmock/gmock.h>
class MockInputFilter : public InputFilter
{
public:
MOCK_METHOD(void, setPrimaryClient, (PrimaryClient *), (override));
};

29
src/test/mock/server/MockPrimaryClient.h
View File

@ -1,29 +0,0 @@
/*
* Deskflow -- mouse and keyboard sharing utility
* SPDX-FileCopyrightText: (C) 2013 - 2016 Symless Ltd.
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/
#pragma once
#define TEST_ENV
#include "server/PrimaryClient.h"
#include <gmock/gmock.h>
class MockPrimaryClient : public PrimaryClient
{
public:
MOCK_METHOD(void *, getEventTarget, (), (const, override));
MOCK_METHOD(void, getCursorPos, (int32_t &, int32_t &), (const, override));
MOCK_METHOD(void, setJumpCursorPos, (int32_t, int32_t), (const));
MOCK_METHOD(void, reconfigure, (uint32_t), (override));
MOCK_METHOD(void, resetOptions, (), (override));
MOCK_METHOD(void, setOptions, (const OptionsList &), (override));
MOCK_METHOD(void, enable, (), (override));
MOCK_METHOD(void, disable, (), (override));
MOCK_METHOD(uint32_t, registerHotKey, (KeyID, KeyModifierMask), (override));
MOCK_METHOD(KeyModifierMask, getToggleMask, (), (const, override));
MOCK_METHOD(void, unregisterHotKey, (uint32_t), (override));
};

38
src/test/shared/TestEventQueue.cpp
View File

@ -1,38 +0,0 @@
/*
* Deskflow -- mouse and keyboard sharing utility
* SPDX-FileCopyrightText: (C) 2013 - 2016 Symless Ltd.
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/
#include "test/shared/TestEventQueue.h"
#include "base/TMethodEventJob.h"
#include <stdexcept>
void TestEventQueue::raiseQuitEvent()
{
addEvent(Event(EventTypes::Quit));
}
void TestEventQueue::initQuitTimeout(double timeout)
{
assert(m_pQuitTimeoutTimer == nullptr);
m_pQuitTimeoutTimer = newOneShotTimer(timeout, nullptr);
adoptHandler(
EventTypes::Timer, m_pQuitTimeoutTimer,
new TMethodEventJob<TestEventQueue>(this, &TestEventQueue::handleQuitTimeout)
);
}
void TestEventQueue::cleanupQuitTimeout()
{
removeHandler(EventTypes::Timer, m_pQuitTimeoutTimer);
deleteTimer(m_pQuitTimeoutTimer);
m_pQuitTimeoutTimer = nullptr;
}
void TestEventQueue::handleQuitTimeout(const Event &, void *vclient)
{
throw std::runtime_error("test event queue timeout");
}

30
src/test/shared/TestEventQueue.h
View File

@ -1,30 +0,0 @@
/*
* Deskflow -- mouse and keyboard sharing utility
* SPDX-FileCopyrightText: (C) 2013 - 2016 Symless Ltd.
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/
#pragma once
#include "base/EventQueue.h"
class EventQueueTimer;
class TestEventQueue : public EventQueue
{
public:
TestEventQueue() : m_pQuitTimeoutTimer(nullptr)
{
}
void handleQuitTimeout(const Event &, void *vclient);
void raiseQuitEvent();
void initQuitTimeout(double timeout);
void cleanupQuitTimeout();
private:
void timeoutThread(void *);
private:
EventQueueTimer *m_pQuitTimeoutTimer;
};

520
src/test/unittests/deskflow/ProtocolUtilTests.cpp
View File

@ -1,520 +0,0 @@
/*
* Deskflow -- mouse and keyboard sharing utility
* SPDX-FileCopyrightText: (C) 2014 - 2020 Symless Ltd.
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/
#include "deskflow/ProtocolUtil.h"
#include "test/mock/io/MockStream.h"
#include <array>
#include <gtest/gtest.h>
using ::testing::_;
using ::testing::DoAll;
using ::testing::ElementsAreArray;
using ::testing::Eq;
using ::testing::Pointee;
using ::testing::Return;
using ::testing::SetArgPointee;
using ::testing::StrEq;
using ::testing::TypedEq;
ACTION_P2(SetValueToVoidPointerArg0, value, size)
{
memcpy(arg0, value, size);
}
MATCHER_P(EqVoidPointeeInt8, expected, "")
{
const uint8_t Actual8 = (*static_cast<const uint8_t *>(arg));
return (expected == Actual8);
}
MATCHER_P(EqVoidPointeeInt16, expected, "")
{
const uint16_t Actual16 = (*static_cast<const uint16_t *>(arg));
return (expected == (Actual16 >> 8));
}
MATCHER_P(EqVoidPointeeInt32, expected, "")
{
const uint32_t Actual32 = (*static_cast<const uint32_t *>(arg));
return (expected == (Actual32 >> 24));
}
MATCHER_P(EqVoidVectorInt1byte, expected, "")
{
bool Result = true;
const uint8_t *Actual = (static_cast<const uint8_t *>(arg)) + 4;
const size_t Size = *(Actual - 1);
if (Size == expected.size()) {
for (size_t i = 0; i < expected.size(); ++i) {
if (expected[i] != Actual[i]) {
Result = false;
break;
}
}
} else {
Result = false;
}
return Result;
}
MATCHER_P(EqVoidVectorInt2bytes, expected, "")
{
bool Result = true;
const uint16_t *Actual = (static_cast<const uint16_t *>(arg)) + 2;
const size_t Size = *(Actual - 1) >> 8;
if (Size == expected.size()) {
for (size_t i = 0; i < expected.size(); ++i) {
if (expected[i] != (Actual[i] >> 8)) {
Result = false;
break;
}
}
} else {
Result = false;
}
return Result;
}
MATCHER_P(EqVoidVectorInt4bytes, expected, "")
{
bool Result = true;
const uint32_t *Actual = (static_cast<const uint32_t *>(arg)) + 1;
const size_t Size = *(Actual - 1) >> 24;
if (Size == expected.size()) {
for (size_t i = 0; i < expected.size(); ++i) {
if (expected[i] != (Actual[i] >> 24)) {
Result = false;
break;
}
}
} else {
Result = false;
}
return Result;
}
MATCHER_P(EqVectorSymbols, expected, "")
{
bool Result = true;
const uint8_t *Actual = (static_cast<const uint8_t *>(arg));
for (size_t i = 0; i < expected.size(); ++i) {
if (expected[i] != (Actual[i])) {
Result = false;
break;
}
}
return Result;
}
ACTION(ThrowBadAlloc)
{
throw std::bad_alloc();
}
class ProtocolUtilTests : public ::testing::Test
{
public:
MockStream stream;
uint8_t ActualInt8 = 0;
uint16_t ActualInt16 = 0;
uint32_t ActualInt32 = 0;
std::string ActualString;
};
// TODO: fix tests causing segmentation fault
#if 0
TEST_F(ProtocolUtilTests, readf__XIOEndOfStream_exception) {
ON_CALL(stream, read(_, _)).WillByDefault(Return(0));
EXPECT_FALSE(ProtocolUtil::readf(&stream, "%s", &ActualString));
EXPECT_TRUE(ActualString.empty());
}
TEST_F(ProtocolUtilTests, readf_XIOReadMismatch_exception) {
EXPECT_CALL(stream, read(_, _))
.WillOnce(DoAll(SetValueToVoidPointerArg0("b", 1), Return(1)));
EXPECT_FALSE(ProtocolUtil::readf(&stream, "a%s", &ActualString));
EXPECT_TRUE(ActualString.empty());
}
TEST_F(ProtocolUtilTests, readf_bad_alloc_exception) {
ON_CALL(stream, read(_, _)).WillByDefault(ThrowBadAlloc());
EXPECT_FALSE(ProtocolUtil::readf(&stream, "a%s", &ActualString));
EXPECT_TRUE(ActualString.empty());
}
TEST_F(ProtocolUtilTests, readf_asserts) {
ASSERT_DEBUG_DEATH(
{ ProtocolUtil::readf(&stream, "%x", &ActualString); },
"invalid format specifier");
ASSERT_DEBUG_DEATH(
{ ProtocolUtil::readf(&stream, "%5i", &ActualString); },
"length to be read is wrong:");
ASSERT_DEBUG_DEATH(
{ ProtocolUtil::readf(&stream, "%5I", &ActualString); }, "");
}
TEST_F(ProtocolUtilTests, readf_params_validation) {
EXPECT_FALSE(ProtocolUtil::readf(nullptr, "%x", nullptr));
EXPECT_FALSE(ProtocolUtil::readf(&stream, nullptr, nullptr));
}
TEST_F(ProtocolUtilTests, readf_string) {
const uint8_t Length = 200;
const std::string Expected(Length, 'x');
std::array<uint8_t, 4> StringSize{{0, 0, 0, Length}};
EXPECT_CALL(stream, read(_, _))
.WillOnce(
DoAll(SetValueToVoidPointerArg0(StringSize.data(), StringSize.size()),
Return(StringSize.size())))
.WillOnce(
DoAll(SetValueToVoidPointerArg0(Expected.c_str(), Expected.length()),
Return(Expected.length())));
EXPECT_TRUE(ProtocolUtil::readf(&stream, "%s", &ActualString));
EXPECT_EQ(Expected, ActualString);
}
class ReadfIntTestFixture
: public ::testing::TestWithParam<std::tuple<const char *, int>> {
public:
MockStream stream;
uint8_t StreamData1Byte = 10;
std::array<uint8_t, 2> StreamData2Bytes{{0, 10}};
std::array<uint8_t, 4> StreamData4Bytes{{0, 0, 0, 10}};
uint8_t *getStreamData(int size) {
uint8_t *StreamData = nullptr;
switch (size) {
case 2:
StreamData = StreamData2Bytes.data();
break;
case 4:
StreamData = StreamData4Bytes.data();
break;
default:
StreamData = &StreamData1Byte;
break;
}
return StreamData;
}
};
TEST_P(ReadfIntTestFixture, readf_int) {
int Actual = 0;
const int Expected = 10;
const char *Format = std::get<0>(GetParam());
int StreamDataSize = std::get<1>(GetParam());
uint8_t *StreamData = getStreamData(StreamDataSize);
ON_CALL(stream, read(_, _))
.WillByDefault(
DoAll(SetValueToVoidPointerArg0(StreamData, StreamDataSize),
Return(StreamDataSize)));
EXPECT_TRUE(ProtocolUtil::readf(&stream, Format, &Actual));
EXPECT_EQ(Expected, Actual);
}
INSTANTIATE_TEST_SUITE_P(ReadfIntTests, ReadfIntTestFixture,
::testing::Values(std::make_tuple("%1i", 1),
std::make_tuple("%2i", 2),
std::make_tuple("%4i", 4)));
class ReadfIntVectorTestFixture : public ReadfIntTestFixture {};
TEST_P(ReadfIntVectorTestFixture, readf_int_vector) {
std::vector<uint8_t> Actual1Byte = {};
std::vector<uint16_t> Actual2Bytes = {};
std::vector<uint32_t> Actual4Bytes = {};
const std::vector<uint8_t> Expected1Byte = {10, 10};
const std::vector<uint16_t> Expected2Bytes = {10, 10};
const std::vector<uint32_t> Expected4Bytes = {10, 10};
std::array<uint8_t, 4> StreamVectorSize{{0, 0, 0, 2}};
const char *Format = std::get<0>(GetParam());
int StreamDataSize = std::get<1>(GetParam());
uint8_t *StreamData = getStreamData(StreamDataSize);
MockStream stream;
EXPECT_CALL(stream, read(_, _))
.WillOnce(DoAll(SetValueToVoidPointerArg0(StreamVectorSize.data(),
StreamVectorSize.size()),
Return(StreamVectorSize.size())))
.WillRepeatedly(
DoAll(SetValueToVoidPointerArg0(StreamData, StreamDataSize),
Return(StreamDataSize)));
switch (StreamDataSize) {
case 2:
EXPECT_TRUE(ProtocolUtil::readf(&stream, Format, &Actual2Bytes));
EXPECT_EQ(Expected2Bytes, Actual2Bytes);
break;
case 4:
EXPECT_TRUE(ProtocolUtil::readf(&stream, Format, &Actual4Bytes));
EXPECT_EQ(Expected4Bytes, Actual4Bytes);
break;
default:
EXPECT_TRUE(ProtocolUtil::readf(&stream, Format, &Actual1Byte));
EXPECT_EQ(Expected1Byte, Actual1Byte);
break;
}
}
INSTANTIATE_TEST_SUITE_P(ReadfIntVectorTests, ReadfIntVectorTestFixture,
::testing::Values(std::make_tuple("%1I", 1),
std::make_tuple("%2I", 2),
std::make_tuple("%4I", 4)));
class ReadfIntAndStringTest : public ReadfIntTestFixture {
public:
uint8_t ActualInt8 = 0;
uint16_t ActualInt16 = 0;
uint32_t ActualInt32 = 32;
std::string ActualString;
};
TEST_P(ReadfIntAndStringTest, readf_int_and_string) {
const int ExpectedInt = 10;
const uint8_t StringLength = 200;
const std::string ExpectedString(StringLength, 'x');
std::array<uint8_t, 4> StringSize{{0, 0, 0, StringLength}};
const char *Format = std::get<0>(GetParam());
int StreamDataSize = std::get<1>(GetParam());
uint8_t *StreamData = getStreamData(StreamDataSize);
EXPECT_CALL(stream, read(_, _))
.WillOnce(DoAll(SetValueToVoidPointerArg0(StreamData, StreamDataSize),
Return(StreamDataSize)))
.WillOnce(
DoAll(SetValueToVoidPointerArg0(StringSize.data(), StringSize.size()),
Return(StringSize.size())))
.WillOnce(DoAll(SetValueToVoidPointerArg0(ExpectedString.c_str(),
ExpectedString.length()),
Return(ExpectedString.length())));
switch (StreamDataSize) {
case 2:
EXPECT_TRUE(
ProtocolUtil::readf(&stream, Format, &ActualInt16, &ActualString));
EXPECT_EQ(ExpectedInt, ActualInt16);
break;
case 4:
EXPECT_TRUE(
ProtocolUtil::readf(&stream, Format, &ActualInt32, &ActualString));
EXPECT_EQ(ExpectedInt, ActualInt32);
break;
default:
EXPECT_TRUE(
ProtocolUtil::readf(&stream, Format, &ActualInt8, &ActualString));
EXPECT_EQ(ExpectedInt, ActualInt8);
break;
}
EXPECT_EQ(ExpectedString, ActualString);
}
INSTANTIATE_TEST_SUITE_P(IntAndStringTest, ReadfIntAndStringTest,
::testing::Values(std::make_tuple("%1i%s", 1),
std::make_tuple("%2i%s", 2),
std::make_tuple("%4i%s", 4)));
TEST_F(ProtocolUtilTests, readf_string_and_int4bytes) {
const uint8_t ExpectedInt = 10;
std::array<uint8_t, 4> StreamIntData{{0, 0, 0, ExpectedInt}};
const std::string ExpectedStr(32768, 'x');
std::array<uint8_t, 4> Size{{0, 0, 128, 0}};
EXPECT_CALL(stream, read(_, _))
.WillOnce(DoAll(SetValueToVoidPointerArg0(Size.data(), Size.size()),
Return(Size.size())))
.WillOnce(DoAll(
SetValueToVoidPointerArg0(ExpectedStr.c_str(), ExpectedStr.length()),
Return(ExpectedStr.length())))
.WillOnce(DoAll(
SetValueToVoidPointerArg0(StreamIntData.data(), StreamIntData.size()),
Return(StreamIntData.size())));
EXPECT_TRUE(
ProtocolUtil::readf(&stream, "%s%4i", &ActualString, &ActualInt32));
EXPECT_EQ(ExpectedStr, ActualString);
EXPECT_EQ(ExpectedInt, ActualInt32);
}
TEST_F(ProtocolUtilTests, readf_string_and_vector_int4bytes) {
std::vector<uint32_t> Actual = {};
const std::vector<uint32_t> Expected4Bytes = {10, 10};
std::array<uint8_t, 4> StreamVectorSize{{0, 0, 0, 2}};
std::array<uint8_t, 4> StreamData4Bytes{{0, 0, 0, 10}};
const std::string ExpString(32768, 'x');
std::array<uint8_t, 4> SizeString{{0, 0, 128, 0}};
EXPECT_CALL(stream, read(_, _))
.WillOnce(
DoAll(SetValueToVoidPointerArg0(SizeString.data(), SizeString.size()),
Return(SizeString.size())))
.WillOnce(DoAll(
SetValueToVoidPointerArg0(ExpString.c_str(), ExpString.length()),
Return(ExpString.length())))
.WillOnce(DoAll(SetValueToVoidPointerArg0(StreamVectorSize.data(),
StreamVectorSize.size()),
Return(StreamVectorSize.size())))
.WillRepeatedly(DoAll(SetValueToVoidPointerArg0(StreamData4Bytes.data(),
StreamData4Bytes.size()),
Return(StreamData4Bytes.size())));
EXPECT_TRUE(ProtocolUtil::readf(&stream, "%s%4I", &ActualString, &Actual));
EXPECT_EQ(ExpString, ActualString);
EXPECT_EQ(Expected4Bytes, Actual);
}
TEST_F(ProtocolUtilTests, readf_vector_int4bytes_and_string) {
std::vector<uint32_t> Actual4Bytes = {};
const std::vector<uint32_t> Expected4Bytes = {10, 10};
std::array<uint8_t, 4> StreamVectorSize{{0, 0, 0, 2}};
std::array<uint8_t, 4> StreamData4Bytes{{0, 0, 0, 10}};
const std::string ExpectedString(32768, 'x');
std::array<uint8_t, 4> StringSize{{0, 0, 128, 0}};
EXPECT_CALL(stream, read(_, _))
.WillOnce(DoAll(SetValueToVoidPointerArg0(StreamVectorSize.data(),
StreamVectorSize.size()),
Return(StreamVectorSize.size())))
.WillOnce(DoAll(SetValueToVoidPointerArg0(StreamData4Bytes.data(),
StreamData4Bytes.size()),
Return(StreamData4Bytes.size())))
.WillOnce(DoAll(SetValueToVoidPointerArg0(StreamData4Bytes.data(),
StreamData4Bytes.size()),
Return(StreamData4Bytes.size())))
.WillOnce(
DoAll(SetValueToVoidPointerArg0(StringSize.data(), StringSize.size()),
Return(StringSize.size())))
.WillOnce(DoAll(SetValueToVoidPointerArg0(ExpectedString.c_str(),
ExpectedString.length()),
Return(ExpectedString.length())));
EXPECT_TRUE(
ProtocolUtil::readf(&stream, "%4I%s", &Actual4Bytes, &ActualString));
EXPECT_EQ(ExpectedString, ActualString);
EXPECT_EQ(Expected4Bytes, Actual4Bytes);
}
class WriteIntTest
: public ::testing::TestWithParam<std::tuple<const char *, int>> {
public:
MockStream stream;
uint8_t Expected1Byte = 5;
uint16_t Expected2Bytes = 10;
uint32_t Expected4Bytes = 15;
};
TEST_P(WriteIntTest, write_int) {
const char *Format = std::get<0>(GetParam());
const int DataSize = std::get<1>(GetParam());
switch (DataSize) {
case 2:
EXPECT_CALL(stream,
write(EqVoidPointeeInt16(Expected2Bytes), Eq(DataSize)));
ProtocolUtil::writef(&stream, Format, Expected2Bytes);
break;
case 4:
EXPECT_CALL(stream,
write(EqVoidPointeeInt32(Expected4Bytes), Eq(DataSize)));
ProtocolUtil::writef(&stream, Format, Expected4Bytes);
break;
default:
EXPECT_CALL(stream, write(EqVoidPointeeInt8(Expected1Byte), Eq(DataSize)));
ProtocolUtil::writef(&stream, Format, Expected1Byte);
break;
}
}
INSTANTIATE_TEST_SUITE_P(WriteIntTest, WriteIntTest,
::testing::Values(std::make_tuple("%1i", 1),
std::make_tuple("%2i", 2),
std::make_tuple("%4i", 4)));
class WriteIntVectorTest
: public ::testing::TestWithParam<std::tuple<const char *, int>> {
public:
MockStream stream;
const std::vector<uint8_t> Expected1Byte = {10, 20, 30};
const std::vector<uint16_t> Expected2Byte = {40, 50, 60};
const std::vector<uint32_t> Expected4Byte = {70, 80, 90};
};
TEST_P(WriteIntVectorTest, write_vector_int) {
const char *Format = std::get<0>(GetParam());
const int Type = std::get<1>(GetParam());
switch (Type) {
case 2:
EXPECT_CALL(stream,
write(EqVoidVectorInt2bytes(Expected2Byte),
Eq(Type * Expected2Byte.size() + sizeof(uint32_t))));
ProtocolUtil::writef(&stream, Format, &Expected2Byte);
break;
case 4:
EXPECT_CALL(stream,
write(EqVoidVectorInt4bytes(Expected4Byte),
Eq(Type * Expected4Byte.size() + sizeof(uint32_t))));
ProtocolUtil::writef(&stream, Format, &Expected4Byte);
break;
default:
EXPECT_CALL(stream, write(EqVoidVectorInt1byte(Expected1Byte),
Eq(Expected1Byte.size() + sizeof(uint32_t))));
ProtocolUtil::writef(&stream, Format, &Expected1Byte);
break;
}
}
INSTANTIATE_TEST_SUITE_P(WriteIntVectorTest, WriteIntVectorTest,
::testing::Values(std::make_tuple("%1I", 1),
std::make_tuple("%2I", 2),
std::make_tuple("%4I", 4)));
TEST_F(ProtocolUtilTests, write_string_test) {
const std::string Expected = "Expected";
const std::vector<uint8_t> ExpectedVector = {'E', 'x', 'p', 'e',
'c', 't', 'e', 'd'};
EXPECT_CALL(stream, write(EqVoidVectorInt1byte(ExpectedVector),
Expected.size() + sizeof(uint32_t)));
ProtocolUtil::writef(&stream, "%s", &Expected);
}
TEST_F(ProtocolUtilTests, write_raw_bytes_test) {
const uint32_t Size = 5;
const std::array<uint8_t, Size> Expected{{10, 20, 30, 40, 50}};
EXPECT_CALL(stream, write(EqVoidVectorInt1byte(Expected),
Expected.size() + sizeof(uint32_t)));
ProtocolUtil::writef(&stream, "%S", Size, &Expected);
}
TEST_F(ProtocolUtilTests, write_symbols_from_format_test) {
const std::vector<uint8_t> Expected = {'%', '1', '2', '3', '4', '5'};
EXPECT_CALL(stream, write(EqVectorSymbols(Expected), Expected.size()));
ProtocolUtil::writef(&stream, "%%12345");
}
#endif

2
src/test/unittests/deskflow/ServerAppTests.cpp
View File

@ -4,8 +4,6 @@
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/
#define TEST_ENV
#include "deskflow/ArgParser.h"
#include "deskflow/ServerApp.h"
#include "deskflow/ServerArgs.h"

522
src/test/unittests/net/NetworkTests.cpp
View File

@ -1,522 +0,0 @@
/*
* Deskflow -- mouse and keyboard sharing utility
* SPDX-FileCopyrightText: (C) 2025 Deskflow Developers
* SPDX-FileCopyrightText: (C) 2013 - 2016 Symless Ltd.
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/
// TODO: fix, tests failing intermittently and/or with segfault
#if 0
#define TEST_ENV
#include "base/Log.h"
#include "base/TMethodEventJob.h"
#include "base/TMethodJob.h"
#include "client/Client.h"
#include "deskflow/FileChunk.h"
#include "deskflow/StreamChunker.h"
#include "mt/Thread.h"
#include "net/NetworkAddress.h"
#include "net/SocketMultiplexer.h"
#include "net/TCPSocketFactory.h"
#include "server/ClientListener.h"
#include "server/ClientProxy.h"
#include "server/Server.h"
#include "test/mock/deskflow/MockScreen.h"
#include "test/mock/server/MockConfig.h"
#include "test/mock/server/MockInputFilter.h"
#include "test/mock/server/MockPrimaryClient.h"
#include "test/shared/TestEventQueue.h"
#include <fstream>
#include <gtest/gtest.h>
#include <iostream>
#include <stdexcept>
#include <stdio.h>
using namespace std;
using ::testing::_;
using ::testing::Invoke;
using ::testing::NiceMock;
using ::testing::Return;
#define TEST_PORT 24803
#define TEST_HOST "localhost"
const size_t kMockDataSize = 1024 * 1024 * 10; // 10MB
const uint16_t kMockDataChunkIncrement = 1024; // 1KB
const char *kMockFilename = "tmp/test/NetworkTests.mock";
const size_t kMockFileSize = 1024 * 1024 * 10; // 10MB
void getScreenShape(int32_t &x, int32_t &y, int32_t &w, int32_t &h);
void getCursorPos(int32_t &x, int32_t &y);
uint8_t *newMockData(size_t size);
void createFile(fstream &file, const char *filename, size_t size);
class NetworkTests : public ::testing::Test {
public:
NetworkTests() : m_mockData(nullptr), m_mockDataSize(0), m_mockFileSize(0) {
m_mockData = newMockData(kMockDataSize);
createFile(m_mockFile, kMockFilename, kMockFileSize);
}
~NetworkTests() {
remove(kMockFilename);
delete[] m_mockData;
}
void sendMockData(void *eventTarget);
void
sendToClient_mockData_handleClientConnected(const Event &, void *vlistener);
void sendToClient_mockData_fileReceiveCompleted(const Event &, void *);
void
sendToClient_mockFile_handleClientConnected(const Event &, void *vlistener);
void sendToClient_mockFile_fileReceiveCompleted(const Event &event, void *);
void
sendToServer_mockData_handleClientConnected(const Event &, void *vlistener);
void sendToServer_mockData_fileReceiveCompleted(const Event &event, void *);
void
sendToServer_mockFile_handleClientConnected(const Event &, void *vlistener);
void sendToServer_mockFile_fileReceiveCompleted(const Event &event, void *);
public:
TestEventQueue m_events;
uint8_t *m_mockData;
size_t m_mockDataSize;
fstream m_mockFile;
size_t m_mockFileSize;
};
TEST_F(NetworkTests, sendToClient_mockData) {
// server and client
NetworkAddress serverAddress(TEST_HOST, TEST_PORT);
serverAddress.resolve();
// server
SocketMultiplexer serverSocketMultiplexer;
TCPSocketFactory *serverSocketFactory =
new TCPSocketFactory(&m_events, &serverSocketMultiplexer);
ClientListener listener(serverAddress, serverSocketFactory, &m_events, SecurityLevel::PlainText);
NiceMock<MockScreen> serverScreen;
NiceMock<MockPrimaryClient> primaryClient;
NiceMock<MockConfig> serverConfig;
NiceMock<MockInputFilter> serverInputFilter;
m_events.adoptHandler(
m_events.forClientListener().connected(), &listener,
new TMethodEventJob<NetworkTests>(
this, &NetworkTests::sendToClient_mockData_handleClientConnected,
&listener));
ON_CALL(serverConfig, isScreen(_)).WillByDefault(Return(true));
ON_CALL(serverConfig, getInputFilter())
.WillByDefault(Return(&serverInputFilter));
deskflow::ServerArgs serverArgs;
serverArgs.m_enableDragDrop = true;
Server server(
serverConfig, &primaryClient, &serverScreen, &m_events, serverArgs);
server.m_mock = true;
listener.setServer(&server);
// client
NiceMock<MockScreen> clientScreen;
SocketMultiplexer clientSocketMultiplexer;
TCPSocketFactory *clientSocketFactory =
new TCPSocketFactory(&m_events, &clientSocketMultiplexer);
ON_CALL(clientScreen, getShape(_, _, _, _))
.WillByDefault(Invoke(getScreenShape));
ON_CALL(clientScreen, getCursorPos(_, _)).WillByDefault(Invoke(getCursorPos));
deskflow::ClientArgs clientArgs;
clientArgs.m_enableDragDrop = true;
clientArgs.m_enableCrypto = false;
Client client(
&m_events, "stub", serverAddress, clientSocketFactory, &clientScreen,
clientArgs);
m_events.adoptHandler(
m_events.forFile().fileReceiveCompleted(), &client,
new TMethodEventJob<NetworkTests>(
this, &NetworkTests::sendToClient_mockData_fileReceiveCompleted));
client.connect();
m_events.initQuitTimeout(10);
m_events.loop();
m_events.removeHandler(m_events.forClientListener().connected(), &listener);
m_events.removeHandler(m_events.forFile().fileReceiveCompleted(), &client);
m_events.cleanupQuitTimeout();
}
TEST_F(NetworkTests, sendToClient_mockFile) {
// server and client
NetworkAddress serverAddress(TEST_HOST, TEST_PORT);
serverAddress.resolve();
// server
SocketMultiplexer serverSocketMultiplexer;
TCPSocketFactory *serverSocketFactory =
new TCPSocketFactory(&m_events, &serverSocketMultiplexer);
ClientListener listener(serverAddress, serverSocketFactory, &m_events, SecurityLevel::PlainText);
NiceMock<MockScreen> serverScreen;
NiceMock<MockPrimaryClient> primaryClient;
NiceMock<MockConfig> serverConfig;
NiceMock<MockInputFilter> serverInputFilter;
m_events.adoptHandler(
m_events.forClientListener().connected(), &listener,
new TMethodEventJob<NetworkTests>(
this, &NetworkTests::sendToClient_mockFile_handleClientConnected,
&listener));
ON_CALL(serverConfig, isScreen(_)).WillByDefault(Return(true));
ON_CALL(serverConfig, getInputFilter())
.WillByDefault(Return(&serverInputFilter));
deskflow::ServerArgs serverArgs;
serverArgs.m_enableDragDrop = true;
Server server(
serverConfig, &primaryClient, &serverScreen, &m_events, serverArgs);
server.m_mock = true;
listener.setServer(&server);
// client
NiceMock<MockScreen> clientScreen;
SocketMultiplexer clientSocketMultiplexer;
TCPSocketFactory *clientSocketFactory =
new TCPSocketFactory(&m_events, &clientSocketMultiplexer);
ON_CALL(clientScreen, getShape(_, _, _, _))
.WillByDefault(Invoke(getScreenShape));
ON_CALL(clientScreen, getCursorPos(_, _)).WillByDefault(Invoke(getCursorPos));
deskflow::ClientArgs clientArgs;
clientArgs.m_enableDragDrop = true;
clientArgs.m_enableCrypto = false;
Client client(
&m_events, "stub", serverAddress, clientSocketFactory, &clientScreen,
clientArgs);
m_events.adoptHandler(
m_events.forFile().fileReceiveCompleted(), &client,
new TMethodEventJob<NetworkTests>(
this, &NetworkTests::sendToClient_mockFile_fileReceiveCompleted));
client.connect();
m_events.initQuitTimeout(10);
m_events.loop();
m_events.removeHandler(m_events.forClientListener().connected(), &listener);
m_events.removeHandler(m_events.forFile().fileReceiveCompleted(), &client);
m_events.cleanupQuitTimeout();
}
TEST_F(NetworkTests, sendToServer_mockData) {
// server and client
NetworkAddress serverAddress(TEST_HOST, TEST_PORT);
serverAddress.resolve();
// server
SocketMultiplexer serverSocketMultiplexer;
TCPSocketFactory *serverSocketFactory =
new TCPSocketFactory(&m_events, &serverSocketMultiplexer);
ClientListener listener(serverAddress, serverSocketFactory, &m_events, SecurityLevel::PlainText);
NiceMock<MockScreen> serverScreen;
NiceMock<MockPrimaryClient> primaryClient;
NiceMock<MockConfig> serverConfig;
NiceMock<MockInputFilter> serverInputFilter;
ON_CALL(serverConfig, isScreen(_)).WillByDefault(Return(true));
ON_CALL(serverConfig, getInputFilter())
.WillByDefault(Return(&serverInputFilter));
deskflow::ServerArgs serverArgs;
serverArgs.m_enableDragDrop = true;
Server server(
serverConfig, &primaryClient, &serverScreen, &m_events, serverArgs);
server.m_mock = true;
listener.setServer(&server);
// client
NiceMock<MockScreen> clientScreen;
SocketMultiplexer clientSocketMultiplexer;
TCPSocketFactory *clientSocketFactory =
new TCPSocketFactory(&m_events, &clientSocketMultiplexer);
ON_CALL(clientScreen, getShape(_, _, _, _))
.WillByDefault(Invoke(getScreenShape));
ON_CALL(clientScreen, getCursorPos(_, _)).WillByDefault(Invoke(getCursorPos));
deskflow::ClientArgs clientArgs;
clientArgs.m_enableDragDrop = true;
clientArgs.m_enableCrypto = false;
Client client(
&m_events, "stub", serverAddress, clientSocketFactory, &clientScreen,
clientArgs);
m_events.adoptHandler(
m_events.forClientListener().connected(), &listener,
new TMethodEventJob<NetworkTests>(
this, &NetworkTests::sendToServer_mockData_handleClientConnected,
&client));
m_events.adoptHandler(
m_events.forFile().fileReceiveCompleted(), &server,
new TMethodEventJob<NetworkTests>(
this, &NetworkTests::sendToServer_mockData_fileReceiveCompleted));
client.connect();
m_events.initQuitTimeout(10);
m_events.loop();
m_events.removeHandler(m_events.forClientListener().connected(), &listener);
m_events.removeHandler(m_events.forFile().fileReceiveCompleted(), &server);
m_events.cleanupQuitTimeout();
}
TEST_F(NetworkTests, sendToServer_mockFile) {
// server and client
NetworkAddress serverAddress(TEST_HOST, TEST_PORT);
serverAddress.resolve();
// server
SocketMultiplexer serverSocketMultiplexer;
TCPSocketFactory *serverSocketFactory =
new TCPSocketFactory(&m_events, &serverSocketMultiplexer);
ClientListener listener(serverAddress, serverSocketFactory, &m_events, SecurityLevel::PlainText);
NiceMock<MockScreen> serverScreen;
NiceMock<MockPrimaryClient> primaryClient;
NiceMock<MockConfig> serverConfig;
NiceMock<MockInputFilter> serverInputFilter;
ON_CALL(serverConfig, isScreen(_)).WillByDefault(Return(true));
ON_CALL(serverConfig, getInputFilter())
.WillByDefault(Return(&serverInputFilter));
deskflow::ServerArgs serverArgs;
serverArgs.m_enableDragDrop = true;
Server server(
serverConfig, &primaryClient, &serverScreen, &m_events, serverArgs);
server.m_mock = true;
listener.setServer(&server);
// client
NiceMock<MockScreen> clientScreen;
SocketMultiplexer clientSocketMultiplexer;
TCPSocketFactory *clientSocketFactory =
new TCPSocketFactory(&m_events, &clientSocketMultiplexer);
ON_CALL(clientScreen, getShape(_, _, _, _))
.WillByDefault(Invoke(getScreenShape));
ON_CALL(clientScreen, getCursorPos(_, _)).WillByDefault(Invoke(getCursorPos));
deskflow::ClientArgs clientArgs;
clientArgs.m_enableDragDrop = true;
clientArgs.m_enableCrypto = false;
Client client(
&m_events, "stub", serverAddress, clientSocketFactory, &clientScreen,
clientArgs);
m_events.adoptHandler(
m_events.forClientListener().connected(), &listener,
new TMethodEventJob<NetworkTests>(
this, &NetworkTests::sendToServer_mockFile_handleClientConnected,
&client));
m_events.adoptHandler(
m_events.forFile().fileReceiveCompleted(), &server,
new TMethodEventJob<NetworkTests>(
this, &NetworkTests::sendToServer_mockFile_fileReceiveCompleted));
client.connect();
m_events.initQuitTimeout(10);
m_events.loop();
m_events.removeHandler(m_events.forClientListener().connected(), &listener);
m_events.removeHandler(m_events.forFile().fileReceiveCompleted(), &server);
m_events.cleanupQuitTimeout();
}
void NetworkTests::sendToClient_mockData_handleClientConnected(
const Event &, void *vlistener) {
ClientListener *listener = static_cast<ClientListener *>(vlistener);
Server *server = listener->getServer();
ClientProxy *client = listener->getNextClient();
if (client == nullptr) {
throw runtime_error("client is null");
}
BaseClientProxy *bcp = client;
server->adoptClient(bcp);
server->setActive(bcp);
sendMockData(server);
}
void NetworkTests::sendToClient_mockData_fileReceiveCompleted(
const Event &event, void *) {
Client *client = static_cast<Client *>(event.getTarget());
EXPECT_TRUE(client->isReceivedFileSizeValid());
m_events.raiseQuitEvent();
}
void NetworkTests::sendToClient_mockFile_handleClientConnected(
const Event &, void *vlistener) {
ClientListener *listener = static_cast<ClientListener *>(vlistener);
Server *server = listener->getServer();
ClientProxy *client = listener->getNextClient();
if (client == nullptr) {
throw runtime_error("client is null");
}
BaseClientProxy *bcp = client;
server->adoptClient(bcp);
server->setActive(bcp);
server->sendFileToClient(kMockFilename);
}
void NetworkTests::sendToClient_mockFile_fileReceiveCompleted(
const Event &event, void *) {
Client *client = static_cast<Client *>(event.getTarget());
EXPECT_TRUE(client->isReceivedFileSizeValid());
m_events.raiseQuitEvent();
}
void NetworkTests::sendToServer_mockData_handleClientConnected(
const Event &, void *vclient) {
Client *client = static_cast<Client *>(vclient);
sendMockData(client);
}
void NetworkTests::sendToServer_mockData_fileReceiveCompleted(
const Event &event, void *) {
Server *server = static_cast<Server *>(event.getTarget());
EXPECT_TRUE(server->isReceivedFileSizeValid());
m_events.raiseQuitEvent();
}
void NetworkTests::sendToServer_mockFile_handleClientConnected(
const Event &, void *vclient) {
Client *client = static_cast<Client *>(vclient);
client->sendFileToServer(kMockFilename);
}
void NetworkTests::sendToServer_mockFile_fileReceiveCompleted(
const Event &event, void *) {
Server *server = static_cast<Server *>(event.getTarget());
EXPECT_TRUE(server->isReceivedFileSizeValid());
m_events.raiseQuitEvent();
}
void NetworkTests::sendMockData(void *eventTarget) {
// send first message (file size)
std::string size = deskflow::string::sizeTypeToString(kMockDataSize);
FileChunk *sizeMessage = FileChunk::start(size);
m_events.addEvent(
Event(m_events.forFile().fileChunkSending(), eventTarget, sizeMessage));
// send chunk messages with incrementing chunk size
size_t lastSize = 0;
size_t sentLength = 0;
while (true) {
size_t dataSize = lastSize + kMockDataChunkIncrement;
// make sure we don't read too much from the mock data.
if (sentLength + dataSize > kMockDataSize) {
dataSize = kMockDataSize - sentLength;
}
// first byte is the chunk mark, last is \0
FileChunk *chunk = FileChunk::data(m_mockData, dataSize);
m_events.addEvent(
Event(m_events.forFile().fileChunkSending(), eventTarget, chunk));
sentLength += dataSize;
lastSize = dataSize;
if (sentLength == kMockDataSize) {
break;
}
}
// send last message
FileChunk *transferFinished = FileChunk::end();
m_events.addEvent(Event(
m_events.forFile().fileChunkSending(), eventTarget, transferFinished));
}
uint8_t *newMockData(size_t size) {
uint8_t *buffer = new uint8_t[size];
uint8_t *data = buffer;
const uint8_t head[] = "mock head... ";
size_t headSize = sizeof(head) - 1;
const uint8_t tail[] = "... mock tail";
size_t tailSize = sizeof(tail) - 1;
const uint8_t deskflowRocks[] = "deskflow\0 rocks! ";
size_t deskflowRocksSize = sizeof(deskflowRocks) - 1;
memcpy(data, head, headSize);
data += headSize;
size_t times = (size - headSize - tailSize) / deskflowRocksSize;
for (size_t i = 0; i < times; ++i) {
memcpy(data, deskflowRocks, deskflowRocksSize);
data += deskflowRocksSize;
}
size_t remainder = (size - headSize - tailSize) % deskflowRocksSize;
if (remainder != 0) {
memset(data, '.', remainder);
data += remainder;
}
memcpy(data, tail, tailSize);
return buffer;
}
void createFile(fstream &file, const char *filename, size_t size) {
uint8_t *buffer = newMockData(size);
file.open(filename, ios::out | ios::binary);
if (!file.is_open()) {
throw runtime_error("file not open");
}
file.write(reinterpret_cast<char *>(buffer), size);
file.close();
delete[] buffer;
}
void getScreenShape(int32_t &x, int32_t &y, int32_t &w, int32_t &h) {
x = 0;
y = 0;
w = 1;
h = 1;
}
void getCursorPos(int32_t &x, int32_t &y) {
x = 0;
y = 0;
}
#endif // WINAPI_CARBON

138
src/test/unittests/platform/MSWindowsKeyStateTests.cpp
View File

@ -1,138 +0,0 @@
/*
* Deskflow -- mouse and keyboard sharing utility
* SPDX-FileCopyrightText: (C) 2012 - 2016 Symless Ltd.
* SPDX-FileCopyrightText: (C) 2011 Nick Bolton
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/
// TODO: fix Assertion failed: s_instance != nullptr
#if 0
#define TEST_ENV
#include "base/TMethodJob.h"
#include "platform/MSWindowsDesks.h"
#include "platform/MSWindowsKeyState.h"
#include "platform/MSWindowsScreen.h"
#include "platform/MSWindowsScreenSaver.h"
#include "test/mock/deskflow/MockEventQueue.h"
#include "test/mock/deskflow/MockKeyMap.h"
#include <gmock/gmock.h>
#include <gtest/gtest.h>
// wParam = flags, HIBYTE(lParam) = virtual key, LOBYTE(lParam) = scan code
#define DESKFLOW_MSG_FAKE_KEY DESKFLOW_HOOK_LAST_MSG + 4
using ::testing::_;
using ::testing::NiceMock;
class MSWindowsKeyStateTests : public ::testing::Test {
protected:
virtual void SetUp() {
m_hook.loadLibrary();
m_screensaver = new MSWindowsScreenSaver();
}
virtual void TearDown() { delete m_screensaver; }
MSWindowsDesks *newDesks(IEventQueue *eventQueue) {
return new MSWindowsDesks(
true, false, m_screensaver, eventQueue,
new TMethodJob<MSWindowsKeyStateTests>(
this, &MSWindowsKeyStateTests::updateKeysCB),
false);
}
void *getEventTarget() const {
return const_cast<MSWindowsKeyStateTests *>(this);
}
private:
void updateKeysCB(void *) {}
IScreenSaver *m_screensaver;
MSWindowsHook m_hook;
};
TEST_F(MSWindowsKeyStateTests, disable_eventQueueNotUsed) {
NiceMock<MockEventQueue> eventQueue;
MSWindowsDesks *desks = newDesks(&eventQueue);
MockKeyMap keyMap;
MSWindowsKeyState keyState(
desks, getEventTarget(), &eventQueue, keyMap, {"en"}, true);
EXPECT_CALL(eventQueue, removeHandler(_, _)).Times(0);
keyState.disable();
delete desks;
}
TEST_F(
MSWindowsKeyStateTests,
testAutoRepeat_noRepeatAndButtonIsZero_resultIsTrue) {
NiceMock<MockEventQueue> eventQueue;
MSWindowsDesks *desks = newDesks(&eventQueue);
MockKeyMap keyMap;
MSWindowsKeyState keyState(
desks, getEventTarget(), &eventQueue, keyMap, {"en"}, true);
keyState.setLastDown(1);
bool actual = keyState.testAutoRepeat(true, false, 1);
ASSERT_TRUE(actual);
delete desks;
}
TEST_F(MSWindowsKeyStateTests, testAutoRepeat_pressFalse_lastDownIsZero) {
NiceMock<MockEventQueue> eventQueue;
MSWindowsDesks *desks = newDesks(&eventQueue);
MockKeyMap keyMap;
MSWindowsKeyState keyState(
desks, getEventTarget(), &eventQueue, keyMap, {"en"}, true);
keyState.setLastDown(1);
keyState.testAutoRepeat(false, false, 1);
ASSERT_EQ(0, keyState.getLastDown());
delete desks;
}
TEST_F(MSWindowsKeyStateTests, saveModifiers_noModifiers_savedModifiers0) {
NiceMock<MockEventQueue> eventQueue;
MSWindowsDesks *desks = newDesks(&eventQueue);
MockKeyMap keyMap;
MSWindowsKeyState keyState(
desks, getEventTarget(), &eventQueue, keyMap, {"en"}, true);
keyState.saveModifiers();
ASSERT_EQ(0, keyState.getSavedModifiers());
delete desks;
}
TEST_F(
MSWindowsKeyStateTests, testKoreanLocale_inputModeKey_resultCorrectKeyID) {
NiceMock<MockEventQueue> eventQueue;
MSWindowsDesks *desks = newDesks(&eventQueue);
MockKeyMap keyMap;
MSWindowsKeyState keyState(
desks, getEventTarget(), &eventQueue, keyMap, {"en"}, true);
keyState.setKeyLayout((HKL)0x00000412u); // for ko-KR local ID
ASSERT_EQ(
0xEF31, keyState.getKeyID(0x15u, 0x1f2u)); // VK_HANGUL from Hangul key
ASSERT_EQ(
0xEF34, keyState.getKeyID(0x19u, 0x1f1u)); // VK_HANJA from Hanja key
ASSERT_EQ(
0xEF31, keyState.getKeyID(0x15u, 0x11du)); // VK_HANGUL from R-Alt key
ASSERT_EQ(
0xEF34, keyState.getKeyID(0x19u, 0x138u)); // VK_HANJA from R-Ctrl key
keyState.setKeyLayout((HKL)0x00000411); // for ja-jp locale ID
ASSERT_EQ(0xEF26, keyState.getKeyID(0x15u, 0x1du)); // VK_KANA
ASSERT_EQ(0xEF2A, keyState.getKeyID(0x19u, 0x38u)); // VK_KANJI
delete desks;
}
#endif

208
src/test/unittests/platform/XWindowsKeyStateTests.cpp
View File

@ -1,208 +0,0 @@
/*
* Deskflow -- mouse and keyboard sharing utility
* SPDX-FileCopyrightText: (C) 2012 - 2016 Symless Ltd.
* SPDX-FileCopyrightText: (C) 2011 Nick Bolton
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/
// TODO: fix Assertion `s_instance != nullptr' failed.
#if 0
#define TEST_ENV
#include "test/mock/deskflow/MockEventQueue.h"
#include "test/mock/deskflow/MockKeyMap.h"
#include "base/Log.h"
#include "platform/XWindowsKeyState.h"
#define XK_LATIN1
#define XK_MISCELLANY
#include <X11/keysymdef.h>
#if HAVE_XKB_EXTENSION
#include <X11/XKBlib.h>
#endif
#include <errno.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
class XWindowsKeyStateTests : public ::testing::Test {
protected:
XWindowsKeyStateTests() : m_display(nullptr) {}
~XWindowsKeyStateTests() {
if (m_display != nullptr) {
LOG((CLOG_DEBUG "closing display"));
XCloseDisplay(m_display);
}
}
virtual void SetUp() {
// open the display only once for the entire test suite
if (this->m_display == nullptr) {
LOG((CLOG_DEBUG "opening display"));
this->m_display = XOpenDisplay(nullptr);
ASSERT_TRUE(this->m_display != nullptr)
<< "unable to open display: " << errno;
}
}
virtual void TearDown() {}
Display *m_display;
};
TEST_F(XWindowsKeyStateTests, setActiveGroup_pollAndSet_groupIsZero) {
MockKeyMap keyMap;
MockEventQueue eventQueue;
XWindowsKeyState keyState(m_display, true, &eventQueue, keyMap);
keyState.setActiveGroup(XWindowsKeyState::kGroupPollAndSet);
ASSERT_EQ(0, keyState.group());
}
TEST_F(XWindowsKeyStateTests, setActiveGroup_poll_groupIsNotSet) {
MockKeyMap keyMap;
MockEventQueue eventQueue;
XWindowsKeyState keyState(m_display, true, &eventQueue, keyMap);
keyState.setActiveGroup(XWindowsKeyState::kGroupPoll);
ASSERT_LE(-1, keyState.group());
}
TEST_F(XWindowsKeyStateTests, setActiveGroup_customGroup_groupWasSet) {
MockKeyMap keyMap;
MockEventQueue eventQueue;
XWindowsKeyState keyState(m_display, true, &eventQueue, keyMap);
keyState.setActiveGroup(1);
ASSERT_EQ(1, keyState.group());
}
TEST_F(XWindowsKeyStateTests, mapModifiersFromX_zeroState_zeroMask) {
MockKeyMap keyMap;
MockEventQueue eventQueue;
XWindowsKeyState keyState(m_display, true, &eventQueue, keyMap);
int mask = keyState.mapModifiersFromX(0);
ASSERT_EQ(0, mask);
}
TEST_F(XWindowsKeyStateTests, mapModifiersToX_zeroMask_resultIsTrue) {
MockKeyMap keyMap;
MockEventQueue eventQueue;
XWindowsKeyState keyState(m_display, true, &eventQueue, keyMap);
unsigned int modifiers = 0;
bool result = keyState.mapModifiersToX(0, modifiers);
ASSERT_TRUE(result);
}
TEST_F(XWindowsKeyStateTests, fakeCtrlAltDel_default_returnsFalse) {
MockKeyMap keyMap;
MockEventQueue eventQueue;
XWindowsKeyState keyState(m_display, true, &eventQueue, keyMap);
bool result = keyState.fakeCtrlAltDel();
ASSERT_FALSE(result);
}
TEST_F(XWindowsKeyStateTests, pollActiveModifiers_defaultState_returnsZero) {
MockKeyMap keyMap;
MockEventQueue eventQueue;
XWindowsKeyState keyState(m_display, true, &eventQueue, keyMap);
KeyModifierMask actual = keyState.pollActiveModifiers();
ASSERT_EQ(0, actual);
}
#if 0 // TODO: fix, causes sigsegv
TEST_F(XWindowsKeyStateTests, pollActiveModifiers_shiftKeyDownThenUp_masksAreCorrect)
{
MockKeyMap keyMap;
MockEventQueue eventQueue;
XWindowsKeyState keyState(
m_display, true, &eventQueue, keyMap);
// set mock modifier mapping
std::fill(keyState.modifierFromX().begin(), keyState.modifierFromX().end(), 0);
keyState.modifierFromX()[ShiftMapIndex] = KeyModifierShift;
KeyCode key = XKeysymToKeycode(m_display, XK_Shift_L);
// fake shift key down (without using deskflow)
XTestFakeKeyEvent(m_display, key, true, CurrentTime);
// function under test (1st call)
KeyModifierMask modDown = keyState.pollActiveModifiers();
// fake shift key up (without using deskflow)
XTestFakeKeyEvent(m_display, key, false, CurrentTime);
// function under test (2nd call)
KeyModifierMask modUp = keyState.pollActiveModifiers();
EXPECT_TRUE((modDown & KeyModifierShift) == KeyModifierShift)
<< "shift key not in mask - key was not pressed";
EXPECT_TRUE((modUp & KeyModifierShift) == 0)
<< "shift key still in mask - make sure no keys are being held down";
}
#endif
TEST_F(XWindowsKeyStateTests, pollActiveGroup_defaultState_returnsZero) {
MockKeyMap keyMap;
MockEventQueue eventQueue;
XWindowsKeyState keyState(m_display, true, &eventQueue, keyMap);
int32_t actual = keyState.pollActiveGroup();
ASSERT_EQ(0, actual);
}
TEST_F(XWindowsKeyStateTests, pollActiveGroup_positiveGroup_returnsGroup) {
MockKeyMap keyMap;
MockEventQueue eventQueue;
XWindowsKeyState keyState(m_display, true, &eventQueue, keyMap);
keyState.group(3);
int32_t actual = keyState.pollActiveGroup();
ASSERT_EQ(3, actual);
}
TEST_F(XWindowsKeyStateTests, pollActiveGroup_xkb_areEqual) {
#if HAVE_XKB_EXTENSION
MockKeyMap keyMap;
MockEventQueue eventQueue;
XWindowsKeyState keyState(m_display, true, &eventQueue, keyMap);
// reset the group
keyState.group(-1);
XkbStateRec state;
// compare pollActiveGroup() with XkbGetState()
if (XkbGetState(m_display, XkbUseCoreKbd, &state) == Success) {
int32_t actual = keyState.pollActiveGroup();
ASSERT_EQ(state.group, actual);
} else {
FAIL() << "XkbGetState() returned error " << errno;
}
#else
SUCCEED() << "Xkb extension not installed";
#endif
}
#endif

37
src/test/unittests/platform/XWindowsScreenSaverTests.cpp
View File

@ -1,37 +0,0 @@
/*
* Deskflow -- mouse and keyboard sharing utility
* SPDX-FileCopyrightText: (C) 2012 - 2016 Symless Ltd.
* SPDX-FileCopyrightText: (C) 2011 Nick Bolton
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/
// TODO: fix tests
#if 0
#include "platform/XWindowsScreenSaver.h"
#include "test/mock/deskflow/MockEventQueue.h"
#include <X11/Xlib.h>
#include <gtest/gtest.h>
using ::testing::_;
// TODO: not working on build machine for some reason
TEST(CXWindowsScreenSaverTests, activate_defaultScreen_todo)
{
Display* display = XOpenDisplay(":0.0");
Window window = DefaultRootWindow(display);
MockEventQueue eventQueue;
EXPECT_CALL(eventQueue, removeHandler(_, _)).Times(1);
CXWindowsScreenSaver screenSaver(
display, window, nullptr, &eventQueue);
screenSaver.activate();
bool isActive = screenSaver.isActive();
screenSaver.deactivate();
ASSERT_EQ(true, isActive);
}
#endif

33
src/test/unittests/platform/XWindowsScreenTests.cpp
View File

@ -1,33 +0,0 @@
/*
* Deskflow -- mouse and keyboard sharing utility
* SPDX-FileCopyrightText: (C) 2012 - 2016 Symless Ltd.
* SPDX-FileCopyrightText: (C) 2011 Nick Bolton
* SPDX-License-Identifier: GPL-2.0-only WITH LicenseRef-OpenSSL-Exception
*/
#include "test/mock/deskflow/MockEventQueue.h"
#include <gtest/gtest.h>
#include "platform/XWindowsScreen.h"
using ::testing::_;
// TODO: fix failing tests
#if 0
TEST(CXWindowsScreenTests, fakeMouseMove_nonPrimary_getCursorPosValuesCorrect) {
MockEventQueue eventQueue;
EXPECT_CALL(eventQueue, adoptHandler(_, _, _)).Times(2);
EXPECT_CALL(eventQueue, adoptBuffer(_)).Times(2);
EXPECT_CALL(eventQueue, removeHandler(_, _)).Times(2);
XWindowsScreen screen(
":0.0", false, false, 0, &eventQueue);
screen.fakeMouseMove(10, 20);
int x, y;
screen.getCursorPos(x, y);
ASSERT_EQ(10, x);
ASSERT_EQ(20, y);
}
#endif