backup/barrier
1
0
Fork 0
mirror of https://github.com/debauchee/barrier.git synced 2026-05-09 16:02:46 +08:00
Code Issues Projects Releases Wiki Activity

dropped "c" prefix from class names

Browse Source
This commit is contained in:
Nick Bolton
2014-11-11 13:51:47 +00:00
parent f6c05e7635
commit e8e156f0e2
382 changed files with 7430 additions and 7423 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/test/unittests/Main.cpp
View File

@@ -30,13 +30,13 @@ main(int argc, char **argv)
{
#if SYSAPI_WIN32
// HACK: shouldn't be needed, but logging fails without this.
CArchMiscWindows::setInstanceWin32(GetModuleHandle(NULL));
ArchMiscWindows::setInstanceWin32(GetModuleHandle(NULL));
#endif
CArch arch;
Arch arch;
arch.init();
CLog log;
Log log;
log.setFilter(kDEBUG4);
testing::InitGoogleTest(&argc, argv);

16
src/test/unittests/base/StringTests.cpp
View File

@@ -21,35 +21,35 @@
using namespace synergy;
TEST(CStringTests, format)
TEST(StringTests, format)
{
const char* format = "%%%{1}=%{2}";
const char* arg1 = "answer";
const char* arg2 = "42";
CString result = string::format(format, arg1, arg2);
String result = string::format(format, arg1, arg2);
EXPECT_EQ("%answer=42", result);
}
TEST(CStringTests, findReplaceAll)
TEST(StringTests, findReplaceAll)
{
CString subject = "foobar";
CString find = "bar";
CString replace = "baz";
String subject = "foobar";
String find = "bar";
String replace = "baz";
string::findReplaceAll(subject, find, replace);
EXPECT_EQ("foobaz", subject);
}
TEST(CStringTests, sprintf)
TEST(StringTests, sprintf)
{
const char* format = "%s=%d";
const char* arg1 = "answer";
int arg2 = 42;
CString result = string::sprintf(format, arg1, arg2);
String result = string::sprintf(format, arg1, arg2);
EXPECT_EQ("answer=42", result);
}

22
src/test/unittests/client/ServerProxyTests.cpp
View File

@@ -40,17 +40,17 @@ UInt32 mouseMove_mockRead(void* buffer, UInt32 n);
const UInt8 g_readCryptoIv_bufferLen = 20;
UInt8 g_readCryptoIv_buffer[g_readCryptoIv_bufferLen];
UInt32 g_readCryptoIv_bufferIndex;
CString g_readCryptoIv_result;
String g_readCryptoIv_result;
UInt32 readCryptoIv_mockRead(void* buffer, UInt32 n);
void readCryptoIv_setDecryptIv(const UInt8*);
TEST(CServerProxyTests, mouseMove)
TEST(ServerProxyTests, mouseMove)
{
g_mouseMove_bufferIndex = 0;
NiceMock<CMockEventQueue> eventQueue;
NiceMock<CMockStream> stream;
NiceMock<CMockClient> client;
NiceMock<MockEventQueue> eventQueue;
NiceMock<MockStream> stream;
NiceMock<MockClient> client;
IStreamEvents streamEvents;
streamEvents.setEvents(&eventQueue);
@@ -62,17 +62,17 @@ TEST(CServerProxyTests, mouseMove)
const char data[] = "DSOP\0\0\0\0DMMV\0\1\0\2";
memcpy(g_mouseMove_buffer, data, g_mouseMove_bufferLen);
CServerProxy serverProxy(&client, &stream, &eventQueue);
ServerProxy serverProxy(&client, &stream, &eventQueue);
serverProxy.handleDataForTest();
}
TEST(CServerProxyTests, readCryptoIv)
TEST(ServerProxyTests, readCryptoIv)
{
g_readCryptoIv_bufferIndex = 0;
NiceMock<CMockEventQueue> eventQueue;
NiceMock<CMockClient> client;
NiceMock<CMockStream> stream;
NiceMock<MockEventQueue> eventQueue;
NiceMock<MockClient> client;
NiceMock<MockStream> stream;
IStreamEvents streamEvents;
streamEvents.setEvents(&eventQueue);
@@ -83,7 +83,7 @@ TEST(CServerProxyTests, readCryptoIv)
const char data[] = "DSOP\0\0\0\0DCIV\0\0\0\4mock";
memcpy(g_readCryptoIv_buffer, data, g_readCryptoIv_bufferLen);
CServerProxy serverProxy(&client, &stream, &eventQueue);
ServerProxy serverProxy(&client, &stream, &eventQueue);
serverProxy.handleDataForTest();
EXPECT_EQ("mock", g_readCryptoIv_result);

16
src/test/unittests/server/ClientProxyTests.cpp
View File

@@ -36,20 +36,20 @@ UInt32 g_cryptoIvWrite_readBufferIndex;
void cryptoIv_mockWrite(const void* in, UInt32 n);
UInt8 cryptoIv_mockRead(void* out, UInt32 n);
TEST(CClientProxyTests, cryptoIvWrite)
TEST(ClientProxyTests, cryptoIvWrite)
{
g_cryptoIvWrite_writeBufferIndex = 0;
g_cryptoIvWrite_readBufferIndex = 0;
NiceMock<CMockEventQueue> eventQueue;
NiceMock<CMockStream> innerStream;
NiceMock<CMockServer> server;
CCryptoOptions options("cfb", "mock");
NiceMock<MockEventQueue> eventQueue;
NiceMock<MockStream> innerStream;
NiceMock<MockServer> server;
CryptoOptions options("cfb", "mock");
IStreamEvents streamEvents;
streamEvents.setEvents(&eventQueue);
CCryptoStream* serverStream = new CCryptoStream(&eventQueue, &innerStream, options, false);
CCryptoStream* clientStream = new CCryptoStream(&eventQueue, &innerStream, options, false);
CryptoStream* serverStream = new CryptoStream(&eventQueue, &innerStream, options, false);
CryptoStream* clientStream = new CryptoStream(&eventQueue, &innerStream, options, false);
byte iv[CRYPTO_IV_SIZE];
serverStream->newIv(iv);
@@ -60,7 +60,7 @@ TEST(CClientProxyTests, cryptoIvWrite)
ON_CALL(innerStream, write(_, _)).WillByDefault(Invoke(cryptoIv_mockWrite));
ON_CALL(innerStream, read(_, _)).WillByDefault(Invoke(cryptoIv_mockRead));
CClientProxy1_4 clientProxy("stub", serverStream, &server, &eventQueue);
ClientProxy1_4 clientProxy("stub", serverStream, &server, &eventQueue);
UInt8 buffer[100];
clientStream->read(buffer, 4);

102
src/test/unittests/synergy/ArgParserTests.cpp
View File

@@ -20,109 +20,109 @@
#include "test/global/gtest.h"
TEST(CArgParserTests, isArg_abbreviationsArg_returnTrue)
TEST(ArgParserTests, isArg_abbreviationsArg_returnTrue)
{
int i = 1;
const int argc = 2;
const char* argv[argc] = { "stub", "-t" };
bool result = CArgParser::isArg(i, argc, argv, "-t", NULL);
bool result = ArgParser::isArg(i, argc, argv, "-t", NULL);
EXPECT_EQ(true, result);
}
TEST(CArgParserTests, isArg_fullArg_returnTrue)
TEST(ArgParserTests, isArg_fullArg_returnTrue)
{
int i = 1;
const int argc = 2;
const char* argv[argc] = { "stub", "--test" };
bool result = CArgParser::isArg(i, argc, argv, NULL, "--test");
bool result = ArgParser::isArg(i, argc, argv, NULL, "--test");
EXPECT_EQ(true, result);
}
TEST(CArgParserTests, isArg_missingArgs_returnFalse)
TEST(ArgParserTests, isArg_missingArgs_returnFalse)
{
int i = 1;
const int argc = 2;
const char* argv[argc] = { "stub", "-t" };
CArgParser argParser(NULL);
CArgsBase argsBase;
ArgParser argParser(NULL);
ArgsBase argsBase;
argParser.setArgsBase(argsBase);
bool result = CArgParser::isArg(i, argc, argv, "-t", NULL, 1);
bool result = ArgParser::isArg(i, argc, argv, "-t", NULL, 1);
EXPECT_FALSE(result);
EXPECT_EQ(true, argsBase.m_shouldExit);
}
TEST(CArgParserTests, searchDoubleQuotes_doubleQuotedArg_returnTrue)
TEST(ArgParserTests, searchDoubleQuotes_doubleQuotedArg_returnTrue)
{
CString command("\"stub\"");
String command("\"stub\"");
size_t left = 0;
size_t right = 0;
bool result = CArgParser::searchDoubleQuotes(command, left, right);
bool result = ArgParser::searchDoubleQuotes(command, left, right);
EXPECT_EQ(true, result);
EXPECT_EQ(0, left);
EXPECT_EQ(5, right);
}
TEST(CArgParserTests, searchDoubleQuotes_noDoubleQuotedArg_returnfalse)
TEST(ArgParserTests, searchDoubleQuotes_noDoubleQuotedArg_returnfalse)
{
CString command("stub");
String command("stub");
size_t left = 0;
size_t right = 0;
bool result = CArgParser::searchDoubleQuotes(command, left, right);
bool result = ArgParser::searchDoubleQuotes(command, left, right);
EXPECT_FALSE(result);
EXPECT_EQ(0, left);
EXPECT_EQ(0, right);
}
TEST(CArgParserTests, searchDoubleQuotes_oneDoubleQuoteArg_returnfalse)
TEST(ArgParserTests, searchDoubleQuotes_oneDoubleQuoteArg_returnfalse)
{
CString command("\"stub");
String command("\"stub");
size_t left = 0;
size_t right = 0;
bool result = CArgParser::searchDoubleQuotes(command, left, right);
bool result = ArgParser::searchDoubleQuotes(command, left, right);
EXPECT_FALSE(result);
EXPECT_EQ(0, left);
EXPECT_EQ(0, right);
}
TEST(CArgParserTests, splitCommandString_oneArg_returnArgv)
TEST(ArgParserTests, splitCommandString_oneArg_returnArgv)
{
CString command("stub");
std::vector<CString> argv;
String command("stub");
std::vector<String> argv;
CArgParser::splitCommandString(command, argv);
ArgParser::splitCommandString(command, argv);
EXPECT_EQ(1, argv.size());
EXPECT_EQ("stub", argv.at(0));
}
TEST(CArgParserTests, splitCommandString_twoArgs_returnArgv)
TEST(ArgParserTests, splitCommandString_twoArgs_returnArgv)
{
CString command("stub1 stub2");
std::vector<CString> argv;
String command("stub1 stub2");
std::vector<String> argv;
CArgParser::splitCommandString(command, argv);
ArgParser::splitCommandString(command, argv);
EXPECT_EQ(2, argv.size());
EXPECT_EQ("stub1", argv.at(0));
EXPECT_EQ("stub2", argv.at(1));
}
TEST(CArgParserTests, splitCommandString_doubleQuotedArgs_returnArgv)
TEST(ArgParserTests, splitCommandString_doubleQuotedArgs_returnArgv)
{
CString command("\"stub1\" stub2 \"stub3\"");
std::vector<CString> argv;
String command("\"stub1\" stub2 \"stub3\"");
std::vector<String> argv;
CArgParser::splitCommandString(command, argv);
ArgParser::splitCommandString(command, argv);
EXPECT_EQ(3, argv.size());
EXPECT_EQ("stub1", argv.at(0));
@@ -130,12 +130,12 @@ TEST(CArgParserTests, splitCommandString_doubleQuotedArgs_returnArgv)
EXPECT_EQ("stub3", argv.at(2));
}
TEST(CArgParserTests, splitCommandString_spaceDoubleQuotedArgs_returnArgv)
TEST(ArgParserTests, splitCommandString_spaceDoubleQuotedArgs_returnArgv)
{
CString command("\"stub1\" stub2 \"stub3 space\"");
std::vector<CString> argv;
String command("\"stub1\" stub2 \"stub3 space\"");
std::vector<String> argv;
CArgParser::splitCommandString(command, argv);
ArgParser::splitCommandString(command, argv);
EXPECT_EQ(3, argv.size());
EXPECT_EQ("stub1", argv.at(0));
@@ -143,17 +143,17 @@ TEST(CArgParserTests, splitCommandString_spaceDoubleQuotedArgs_returnArgv)
EXPECT_EQ("stub3 space", argv.at(2));
}
TEST(CArgParserTests, getArgv_stringArray_return2DArray)
TEST(ArgParserTests, getArgv_stringArray_return2DArray)
{
std::vector<CString> argArray;
std::vector<String> argArray;
argArray.push_back("stub1");
argArray.push_back("stub2");
argArray.push_back("stub3 space");
const char** argv = CArgParser::getArgv(argArray);
const char** argv = ArgParser::getArgv(argArray);
CString row1(argv[0]);
CString row2(argv[1]);
CString row3(argv[2]);
String row1(argv[0]);
String row2(argv[1]);
String row3(argv[2]);
EXPECT_EQ("stub1", row1);
EXPECT_EQ("stub2", row2);
@@ -162,45 +162,45 @@ TEST(CArgParserTests, getArgv_stringArray_return2DArray)
delete[] argv;
}
TEST(CArgParserTests, assembleCommand_stringArray_returnCommand)
TEST(ArgParserTests, assembleCommand_stringArray_returnCommand)
{
std::vector<CString> argArray;
std::vector<String> argArray;
argArray.push_back("stub1");
argArray.push_back("stub2");
CString command = CArgParser::assembleCommand(argArray);
String command = ArgParser::assembleCommand(argArray);
EXPECT_EQ("stub1 stub2", command);
}
TEST(CArgParserTests, assembleCommand_ignoreSecondArg_returnCommand)
TEST(ArgParserTests, assembleCommand_ignoreSecondArg_returnCommand)
{
std::vector<CString> argArray;
std::vector<String> argArray;
argArray.push_back("stub1");
argArray.push_back("stub2");
CString command = CArgParser::assembleCommand(argArray, "stub2");
String command = ArgParser::assembleCommand(argArray, "stub2");
EXPECT_EQ("stub1", command);
}
TEST(CArgParserTests, assembleCommand_ignoreSecondArgWithOneParameter_returnCommand)
TEST(ArgParserTests, assembleCommand_ignoreSecondArgWithOneParameter_returnCommand)
{
std::vector<CString> argArray;
std::vector<String> argArray;
argArray.push_back("stub1");
argArray.push_back("stub2");
argArray.push_back("stub3");
argArray.push_back("stub4");
CString command = CArgParser::assembleCommand(argArray, "stub2", 1);
String command = ArgParser::assembleCommand(argArray, "stub2", 1);
EXPECT_EQ("stub1 stub4", command);
}
TEST(CArgParserTests, assembleCommand_stringArrayWithSpace_returnCommand)
TEST(ArgParserTests, assembleCommand_stringArrayWithSpace_returnCommand)
{
std::vector<CString> argArray;
std::vector<String> argArray;
argArray.push_back("stub1 space");
argArray.push_back("stub2");
argArray.push_back("stub3 space");
CString command = CArgParser::assembleCommand(argArray);
String command = ArgParser::assembleCommand(argArray);
EXPECT_EQ("\"stub1 space\" stub2 \"stub3 space\"", command);
}

24
src/test/unittests/synergy/ClientArgsParsingTests.cpp
View File

@@ -37,12 +37,12 @@ client_stubCheckUnexpectedArgs()
return false;
}
TEST(CClientArgsParsingTests, parseClientArgs_yScrollArg_setYScroll)
TEST(ClientArgsParsingTests, parseClientArgs_yScrollArg_setYScroll)
{
NiceMock<CMockArgParser> argParser;
NiceMock<MockArgParser> argParser;
ON_CALL(argParser, parseGenericArgs(_, _, _)).WillByDefault(Invoke(client_stubParseGenericArgs));
ON_CALL(argParser, checkUnexpectedArgs()).WillByDefault(Invoke(client_stubCheckUnexpectedArgs));
CClientArgs clientArgs;
ClientArgs clientArgs;
const int argc = 3;
const char* kYScrollCmd[argc] = { "stub", "--yscroll", "1" };
@@ -51,12 +51,12 @@ TEST(CClientArgsParsingTests, parseClientArgs_yScrollArg_setYScroll)
EXPECT_EQ(1, clientArgs.m_yscroll);
}
TEST(CClientArgsParsingTests, parseClientArgs_addressArg_setSynergyAddress)
TEST(ClientArgsParsingTests, parseClientArgs_addressArg_setSynergyAddress)
{
NiceMock<CMockArgParser> argParser;
NiceMock<MockArgParser> argParser;
ON_CALL(argParser, parseGenericArgs(_, _, _)).WillByDefault(Invoke(client_stubParseGenericArgs));
ON_CALL(argParser, checkUnexpectedArgs()).WillByDefault(Invoke(client_stubCheckUnexpectedArgs));
CClientArgs clientArgs;
ClientArgs clientArgs;
const int argc = 2;
const char* kAddressCmd[argc] = { "stub", "mock_address" };
@@ -66,12 +66,12 @@ TEST(CClientArgsParsingTests, parseClientArgs_addressArg_setSynergyAddress)
EXPECT_EQ(true, result);
}
TEST(CClientArgsParsingTests, parseClientArgs_noAddressArg_returnFalse)
TEST(ClientArgsParsingTests, parseClientArgs_noAddressArg_returnFalse)
{
NiceMock<CMockArgParser> argParser;
NiceMock<MockArgParser> argParser;
ON_CALL(argParser, parseGenericArgs(_, _, _)).WillByDefault(Invoke(client_stubParseGenericArgs));
ON_CALL(argParser, checkUnexpectedArgs()).WillByDefault(Invoke(client_stubCheckUnexpectedArgs));
CClientArgs clientArgs;
ClientArgs clientArgs;
const int argc = 1;
const char* kNoAddressCmd[argc] = { "stub" };
@@ -80,12 +80,12 @@ TEST(CClientArgsParsingTests, parseClientArgs_noAddressArg_returnFalse)
EXPECT_FALSE(result);
}
TEST(CClientArgsParsingTests, parseClientArgs_unrecognizedArg_returnFalse)
TEST(ClientArgsParsingTests, parseClientArgs_unrecognizedArg_returnFalse)
{
NiceMock<CMockArgParser> argParser;
NiceMock<MockArgParser> argParser;
ON_CALL(argParser, parseGenericArgs(_, _, _)).WillByDefault(Invoke(client_stubParseGenericArgs));
ON_CALL(argParser, checkUnexpectedArgs()).WillByDefault(Invoke(client_stubCheckUnexpectedArgs));
CClientArgs clientArgs;
ClientArgs clientArgs;
const int argc = 3;
const char* kUnrecognizedCmd[argc] = { "stub", "mock_arg", "mock_address"};

156
src/test/unittests/synergy/ClipboardTests.cpp
View File

@@ -20,9 +20,9 @@
#include "test/global/gtest.h"
TEST(CClipboardTests, empty_openCalled_returnsTrue)
TEST(ClipboardTests, empty_openCalled_returnsTrue)
{
CClipboard clipboard;
Clipboard clipboard;
clipboard.open(0);
bool actual = clipboard.empty();
@@ -30,62 +30,62 @@ TEST(CClipboardTests, empty_openCalled_returnsTrue)
EXPECT_EQ(true, actual);
}
TEST(CClipboardTests, empty_singleFormat_hasReturnsFalse)
TEST(ClipboardTests, empty_singleFormat_hasReturnsFalse)
{
CClipboard clipboard;
Clipboard clipboard;
clipboard.open(0);
clipboard.add(CClipboard::kText, "synergy rocks!");
clipboard.add(Clipboard::kText, "synergy rocks!");
clipboard.empty();
bool actual = clipboard.has(CClipboard::kText);
bool actual = clipboard.has(Clipboard::kText);
EXPECT_FALSE(actual);
}
TEST(CClipboardTests, add_newValue_valueWasStored)
TEST(ClipboardTests, add_newValue_valueWasStored)
{
CClipboard clipboard;
Clipboard clipboard;
clipboard.open(0);
clipboard.add(IClipboard::kText, "synergy rocks!");
CString actual = clipboard.get(IClipboard::kText);
String actual = clipboard.get(IClipboard::kText);
EXPECT_EQ("synergy rocks!", actual);
}
TEST(CClipboardTests, add_replaceValue_valueWasReplaced)
TEST(ClipboardTests, add_replaceValue_valueWasReplaced)
{
CClipboard clipboard;
Clipboard clipboard;
clipboard.open(0);
clipboard.add(IClipboard::kText, "synergy rocks!");
clipboard.add(IClipboard::kText, "maxivista sucks"); // haha, just kidding.
CString actual = clipboard.get(IClipboard::kText);
String actual = clipboard.get(IClipboard::kText);
EXPECT_EQ("maxivista sucks", actual);
}
TEST(CClipboardTests, open_timeIsZero_returnsTrue)
TEST(ClipboardTests, open_timeIsZero_returnsTrue)
{
CClipboard clipboard;
Clipboard clipboard;
bool actual = clipboard.open(0);
EXPECT_EQ(true, actual);
}
TEST(CClipboardTests, open_timeIsOne_returnsTrue)
TEST(ClipboardTests, open_timeIsOne_returnsTrue)
{
CClipboard clipboard;
Clipboard clipboard;
bool actual = clipboard.open(1);
EXPECT_EQ(true, actual);
}
TEST(CClipboardTests, close_isOpen_noErrors)
TEST(ClipboardTests, close_isOpen_noErrors)
{
CClipboard clipboard;
Clipboard clipboard;
clipboard.open(0);
clipboard.close();
@@ -93,30 +93,30 @@ TEST(CClipboardTests, close_isOpen_noErrors)
// can't assert anything
}
TEST(CClipboardTests, getTime_openWithNoEmpty_returnsZero)
TEST(ClipboardTests, getTime_openWithNoEmpty_returnsZero)
{
CClipboard clipboard;
Clipboard clipboard;
clipboard.open(1);
CClipboard::Time actual = clipboard.getTime();
Clipboard::Time actual = clipboard.getTime();
EXPECT_EQ(0, actual);
}
TEST(CClipboardTests, getTime_openAndEmpty_returnsOne)
TEST(ClipboardTests, getTime_openAndEmpty_returnsOne)
{
CClipboard clipboard;
Clipboard clipboard;
clipboard.open(1);
clipboard.empty();
CClipboard::Time actual = clipboard.getTime();
Clipboard::Time actual = clipboard.getTime();
EXPECT_EQ(1, actual);
}
TEST(CClipboardTests, has_withFormatAdded_returnsTrue)
TEST(ClipboardTests, has_withFormatAdded_returnsTrue)
{
CClipboard clipboard;
Clipboard clipboard;
clipboard.open(0);
clipboard.add(IClipboard::kText, "synergy rocks!");
@@ -125,9 +125,9 @@ TEST(CClipboardTests, has_withFormatAdded_returnsTrue)
EXPECT_EQ(true, actual);
}
TEST(CClipboardTests, has_withNoFormats_returnsFalse)
TEST(ClipboardTests, has_withNoFormats_returnsFalse)
{
CClipboard clipboard;
Clipboard clipboard;
clipboard.open(0);
bool actual = clipboard.has(IClipboard::kText);
@@ -135,59 +135,59 @@ TEST(CClipboardTests, has_withNoFormats_returnsFalse)
EXPECT_FALSE(actual);
}
TEST(CClipboardTests, get_withNoFormats_returnsEmpty)
TEST(ClipboardTests, get_withNoFormats_returnsEmpty)
{
CClipboard clipboard;
Clipboard clipboard;
clipboard.open(0);
CString actual = clipboard.get(IClipboard::kText);
String actual = clipboard.get(IClipboard::kText);
EXPECT_EQ("", actual);
}
TEST(CClipboardTests, get_withFormatAdded_returnsExpected)
TEST(ClipboardTests, get_withFormatAdded_returnsExpected)
{
CClipboard clipboard;
Clipboard clipboard;
clipboard.open(0);
clipboard.add(IClipboard::kText, "synergy rocks!");
CString actual = clipboard.get(IClipboard::kText);
String actual = clipboard.get(IClipboard::kText);
EXPECT_EQ("synergy rocks!", actual);
}
TEST(CClipboardTests, marshall_addNotCalled_firstCharIsZero)
TEST(ClipboardTests, marshall_addNotCalled_firstCharIsZero)
{
CClipboard clipboard;
Clipboard clipboard;
CString actual = clipboard.marshall();
String actual = clipboard.marshall();
// seems to return "\0\0\0\0" but EXPECT_EQ can't assert this,
// so instead, just assert that first char is '\0'.
EXPECT_EQ(0, (int)actual[0]);
}
TEST(CClipboardTests, marshall_withTextAdded_typeCharIsText)
TEST(ClipboardTests, marshall_withTextAdded_typeCharIsText)
{
CClipboard clipboard;
Clipboard clipboard;
clipboard.open(0);
clipboard.add(IClipboard::kText, "synergy rocks!");
clipboard.close();
CString actual = clipboard.marshall();
String actual = clipboard.marshall();
// string contains other data, but 8th char should be kText.
EXPECT_EQ(IClipboard::kText, (int)actual[7]);
}
TEST(CClipboardTests, marshall_withTextAdded_lastSizeCharIs14)
TEST(ClipboardTests, marshall_withTextAdded_lastSizeCharIs14)
{
CClipboard clipboard;
Clipboard clipboard;
clipboard.open(0);
clipboard.add(IClipboard::kText, "synergy rocks!"); // 14 chars
clipboard.close();
CString actual = clipboard.marshall();
String actual = clipboard.marshall();
EXPECT_EQ(14, (int)actual[11]);
}
@@ -195,22 +195,22 @@ TEST(CClipboardTests, marshall_withTextAdded_lastSizeCharIs14)
// TODO: there's some integer -> char encoding going on here. i find it
// hard to believe that the clipboard is the only thing doing this. maybe
// we should refactor this stuff out of the clipboard.
TEST(CClipboardTests, marshall_withTextSize285_sizeCharsValid)
TEST(ClipboardTests, marshall_withTextSize285_sizeCharsValid)
{
// 285 chars
CString data;
String data;
data.append("Synergy is Free and Open Source Software that lets you ");
data.append("easily share your mouse and keyboard between multiple ");
data.append("computers, where each computer has it's own display. No ");
data.append("special hardware is required, all you need is a local area ");
data.append("network. Synergy is supported on Windows, Mac OS X and Linux.");
CClipboard clipboard;
Clipboard clipboard;
clipboard.open(0);
clipboard.add(IClipboard::kText, data);
clipboard.close();
CString actual = clipboard.marshall();
String actual = clipboard.marshall();
// 4 asserts here, but that's ok because we're really just asserting 1
// thing. the 32-bit size value is split into 4 chars. if the size is 285
@@ -225,28 +225,28 @@ TEST(CClipboardTests, marshall_withTextSize285_sizeCharsValid)
EXPECT_EQ(29, actual[11]); // 285 - 256 = 29
}
TEST(CClipboardTests, marshall_withHtmlAdded_typeCharIsHtml)
TEST(ClipboardTests, marshall_withHtmlAdded_typeCharIsHtml)
{
CClipboard clipboard;
Clipboard clipboard;
clipboard.open(0);
clipboard.add(IClipboard::kHTML, "html sucks");
clipboard.close();
CString actual = clipboard.marshall();
String actual = clipboard.marshall();
// string contains other data, but 8th char should be kHTML.
EXPECT_EQ(IClipboard::kHTML, (int)actual[7]);
}
TEST(CClipboardTests, marshall_withHtmlAndText_has2Formats)
TEST(ClipboardTests, marshall_withHtmlAndText_has2Formats)
{
CClipboard clipboard;
Clipboard clipboard;
clipboard.open(0);
clipboard.add(IClipboard::kText, "synergy rocks");
clipboard.add(IClipboard::kHTML, "html sucks");
clipboard.close();
CString actual = clipboard.marshall();
String actual = clipboard.marshall();
// the number of formats is stored inside the first 4 chars.
// the writeUInt32 function right-aligns numbers in 4 chars,
@@ -256,24 +256,24 @@ TEST(CClipboardTests, marshall_withHtmlAndText_has2Formats)
EXPECT_EQ(2, (int)actual[3]);
}
TEST(CClipboardTests, marshall_withTextAdded_endsWithAdded)
TEST(ClipboardTests, marshall_withTextAdded_endsWithAdded)
{
CClipboard clipboard;
Clipboard clipboard;
clipboard.open(0);
clipboard.add(IClipboard::kText, "synergy rocks!");
clipboard.close();
CString actual = clipboard.marshall();
String actual = clipboard.marshall();
// string contains other data, but should end in the string we added.
EXPECT_EQ("synergy rocks!", actual.substr(12));
}
TEST(CClipboardTests, unmarshall_emptyData_hasTextIsFalse)
TEST(ClipboardTests, unmarshall_emptyData_hasTextIsFalse)
{
CClipboard clipboard;
Clipboard clipboard;
CString data;
String data;
data += (char)0;
data += (char)0;
data += (char)0;
@@ -286,19 +286,19 @@ TEST(CClipboardTests, unmarshall_emptyData_hasTextIsFalse)
EXPECT_FALSE(actual);
}
TEST(CClipboardTests, unmarshall_withTextSize285_getTextIsValid)
TEST(ClipboardTests, unmarshall_withTextSize285_getTextIsValid)
{
CClipboard clipboard;
Clipboard clipboard;
// 285 chars
CString text;
String text;
text.append("Synergy is Free and Open Source Software that lets you ");
text.append("easily share your mouse and keyboard between multiple ");
text.append("computers, where each computer has it's own display. No ");
text.append("special hardware is required, all you need is a local area ");
text.append("network. Synergy is supported on Windows, Mac OS X and Linux.");
CString data;
String data;
data += (char)0;
data += (char)0;
data += (char)0;
@@ -316,14 +316,14 @@ TEST(CClipboardTests, unmarshall_withTextSize285_getTextIsValid)
clipboard.unmarshall(data, 0);
clipboard.open(0);
CString actual = clipboard.get(IClipboard::kText);
String actual = clipboard.get(IClipboard::kText);
EXPECT_EQ(text, actual);
}
TEST(CClipboardTests, unmarshall_withTextAndHtml_getTextIsValid)
TEST(ClipboardTests, unmarshall_withTextAndHtml_getTextIsValid)
{
CClipboard clipboard;
CString data;
Clipboard clipboard;
String data;
data += (char)0;
data += (char)0;
data += (char)0;
@@ -350,14 +350,14 @@ TEST(CClipboardTests, unmarshall_withTextAndHtml_getTextIsValid)
clipboard.unmarshall(data, 0);
clipboard.open(0);
CString actual = clipboard.get(IClipboard::kText);
String actual = clipboard.get(IClipboard::kText);
EXPECT_EQ("synergy rocks!", actual);
}
TEST(CClipboardTests, unmarshall_withTextAndHtml_getHtmlIsValid)
TEST(ClipboardTests, unmarshall_withTextAndHtml_getHtmlIsValid)
{
CClipboard clipboard;
CString data;
Clipboard clipboard;
String data;
data += (char)0;
data += (char)0;
data += (char)0;
@@ -384,21 +384,21 @@ TEST(CClipboardTests, unmarshall_withTextAndHtml_getHtmlIsValid)
clipboard.unmarshall(data, 0);
clipboard.open(0);
CString actual = clipboard.get(IClipboard::kHTML);
String actual = clipboard.get(IClipboard::kHTML);
EXPECT_EQ("html sucks", actual);
}
TEST(CClipboardTests, copy_withSingleText_clipboardsAreEqual)
TEST(ClipboardTests, copy_withSingleText_clipboardsAreEqual)
{
CClipboard clipboard1;
Clipboard clipboard1;
clipboard1.open(0);
clipboard1.add(CClipboard::kText, "synergy rocks!");
clipboard1.add(Clipboard::kText, "synergy rocks!");
clipboard1.close();
CClipboard clipboard2;
CClipboard::copy(&clipboard2, &clipboard1);
Clipboard clipboard2;
Clipboard::copy(&clipboard2, &clipboard1);
clipboard2.open(0);
CString actual = clipboard2.get(CClipboard::kText);
String actual = clipboard2.get(Clipboard::kText);
EXPECT_EQ("synergy rocks!", actual);
}

74
src/test/unittests/synergy/CryptoStreamTests.cpp
View File

@@ -60,7 +60,7 @@ UInt8 readWriteIvChangeTrigger_mockRead(void* out, UInt32 n);
UInt8 g_newIvDoesNotChangeIv_buffer[1];
void newIvDoesNotChangeIv_mockWrite(const void* in, UInt32 n);
TEST(CCryptoStreamTests, write)
TEST(CryptoStreamTests, write)
{
const UInt32 size = 4;
UInt8* buffer = new UInt8[size];
@@ -69,13 +69,13 @@ TEST(CCryptoStreamTests, write)
buffer[2] = 'D';
buffer[3] = 'N';
NiceMock<CMockEventQueue> eventQueue;
NiceMock<CMockStream> innerStream;
CCryptoOptions options("cfb", "mock");
NiceMock<MockEventQueue> eventQueue;
NiceMock<MockStream> innerStream;
CryptoOptions options("cfb", "mock");
ON_CALL(innerStream, write(_, _)).WillByDefault(Invoke(write_mockWrite));
CCryptoStream cs(&eventQueue, &innerStream, options, false);
CryptoStream cs(&eventQueue, &innerStream, options, false);
cs.setEncryptIv(kIv);
cs.write(buffer, size);
@@ -85,15 +85,15 @@ TEST(CCryptoStreamTests, write)
EXPECT_EQ(220, g_write_buffer[3]);
}
TEST(CCryptoStreamTests, read)
TEST(CryptoStreamTests, read)
{
NiceMock<CMockEventQueue> eventQueue;
NiceMock<CMockStream> innerStream;
CCryptoOptions options("cfb", "mock");
NiceMock<MockEventQueue> eventQueue;
NiceMock<MockStream> innerStream;
CryptoOptions options("cfb", "mock");
ON_CALL(innerStream, read(_, _)).WillByDefault(Invoke(read_mockRead));
CCryptoStream cs(&eventQueue, &innerStream, options, false);
CryptoStream cs(&eventQueue, &innerStream, options, false);
cs.setEncryptIv(kIv);
cs.setDecryptIv(kIv);
@@ -112,18 +112,18 @@ TEST(CCryptoStreamTests, read)
EXPECT_EQ('N', buffer[3]);
}
TEST(CCryptoStreamTests, write4Read1)
TEST(CryptoStreamTests, write4Read1)
{
g_write4Read1_bufferIndex = 0;
NiceMock<CMockEventQueue> eventQueue;
NiceMock<CMockStream> innerStream;
CCryptoOptions options("cfb", "mock");
NiceMock<MockEventQueue> eventQueue;
NiceMock<MockStream> innerStream;
CryptoOptions options("cfb", "mock");
ON_CALL(innerStream, write(_, _)).WillByDefault(Invoke(write4Read1_mockWrite));
ON_CALL(innerStream, read(_, _)).WillByDefault(Invoke(write4Read1_mockRead));
CCryptoStream cs1(&eventQueue, &innerStream, options, false);
CryptoStream cs1(&eventQueue, &innerStream, options, false);
cs1.setEncryptIv(kIv);
cs1.write("a", 1);
@@ -131,7 +131,7 @@ TEST(CCryptoStreamTests, write4Read1)
cs1.write("c", 1);
cs1.write("d", 1);
CCryptoStream cs2(&eventQueue, &innerStream, options, false);
CryptoStream cs2(&eventQueue, &innerStream, options, false);
cs2.setDecryptIv(kIv);
UInt8 buffer[4];
@@ -143,18 +143,18 @@ TEST(CCryptoStreamTests, write4Read1)
EXPECT_EQ('d', buffer[3]);
}
TEST(CCryptoStreamTests, write1Read4)
TEST(CryptoStreamTests, write1Read4)
{
g_write1Read4_bufferIndex = 0;
NiceMock<CMockEventQueue> eventQueue;
NiceMock<CMockStream> innerStream;
CCryptoOptions options("cfb", "mock");
NiceMock<MockEventQueue> eventQueue;
NiceMock<MockStream> innerStream;
CryptoOptions options("cfb", "mock");
ON_CALL(innerStream, write(_, _)).WillByDefault(Invoke(write1Read4_mockWrite));
ON_CALL(innerStream, read(_, _)).WillByDefault(Invoke(write1Read4_mockRead));
CCryptoStream cs1(&eventQueue, &innerStream, options, false);
CryptoStream cs1(&eventQueue, &innerStream, options, false);
cs1.setEncryptIv(kIv);
UInt8 bufferIn[4];
@@ -164,7 +164,7 @@ TEST(CCryptoStreamTests, write1Read4)
bufferIn[3] = 'd';
cs1.write(bufferIn, 4);
CCryptoStream cs2(&eventQueue, &innerStream, options, false);
CryptoStream cs2(&eventQueue, &innerStream, options, false);
cs2.setDecryptIv(kIv);
UInt8 bufferOut[4];
@@ -179,14 +179,14 @@ TEST(CCryptoStreamTests, write1Read4)
EXPECT_EQ('d', bufferOut[3]);
}
TEST(CCryptoStreamTests, readWriteIvChanged)
TEST(CryptoStreamTests, readWriteIvChanged)
{
g_readWriteIvChangeTrigger_writeBufferIndex = 0;
g_readWriteIvChangeTrigger_readBufferIndex = 0;
NiceMock<CMockEventQueue> eventQueue;
NiceMock<CMockStream> innerStream;
CCryptoOptions options("cfb", "mock");
NiceMock<MockEventQueue> eventQueue;
NiceMock<MockStream> innerStream;
CryptoOptions options("cfb", "mock");
ON_CALL(innerStream, write(_, _)).WillByDefault(Invoke(readWriteIvChanged_mockWrite));
ON_CALL(innerStream, read(_, _)).WillByDefault(Invoke(readWriteIvChanged_mockRead));
@@ -195,7 +195,7 @@ TEST(CCryptoStreamTests, readWriteIvChanged)
const byte iv1[] = "aaaaaaaaaaaaaaaa";
const byte iv2[] = "bbbbbbbbbbbbbbbb";
CCryptoStream cs1(&eventQueue, &innerStream, options, false);
CryptoStream cs1(&eventQueue, &innerStream, options, false);
cs1.setEncryptIv(iv1);
UInt8 bufferIn[4];
@@ -205,7 +205,7 @@ TEST(CCryptoStreamTests, readWriteIvChanged)
bufferIn[3] = 'd';
cs1.write(bufferIn, 4);
CCryptoStream cs2(&eventQueue, &innerStream, options, false);
CryptoStream cs2(&eventQueue, &innerStream, options, false);
cs1.setDecryptIv(iv2);
UInt8 bufferOut[4];
@@ -234,35 +234,35 @@ TEST(CCryptoStreamTests, readWriteIvChanged)
EXPECT_EQ('d', bufferOut[3]);
}
TEST(CCryptoStreamTests, createKey)
TEST(CryptoStreamTests, createKey)
{
byte hash1[16];
CCryptoStream::createKey(hash1, "MockLongPassword", 16, 16);
CryptoStream::createKey(hash1, "MockLongPassword", 16, 16);
EXPECT_EQ(hash1[0], 149);
EXPECT_EQ(hash1[15], 235);
byte hash2[32];
CCryptoStream::createKey(hash2, "MockLongPassword", 32, 16);
CryptoStream::createKey(hash2, "MockLongPassword", 32, 16);
EXPECT_EQ(hash2[0], 149);
EXPECT_EQ(hash2[15], 235);
EXPECT_EQ(hash2[31], 7);
byte hash3[32];
CCryptoStream::createKey(hash3, "7accbf2f86a9191da0947107d4fe7054", 32, 16);
CryptoStream::createKey(hash3, "7accbf2f86a9191da0947107d4fe7054", 32, 16);
EXPECT_EQ(hash3[0], 120);
EXPECT_EQ(hash3[15], 11);
EXPECT_EQ(hash3[31], 233);
}
TEST(CCryptoStreamTests, newIvDoesNotChangeIv)
TEST(CryptoStreamTests, newIvDoesNotChangeIv)
{
NiceMock<CMockEventQueue> eventQueue;
NiceMock<CMockStream> innerStream;
CCryptoOptions options("cfb", "mock");
NiceMock<MockEventQueue> eventQueue;
NiceMock<MockStream> innerStream;
CryptoOptions options("cfb", "mock");
ON_CALL(innerStream, write(_, _)).WillByDefault(Invoke(newIvDoesNotChangeIv_mockWrite));
CCryptoStream cs1(&eventQueue, &innerStream, options, false);
CryptoStream cs1(&eventQueue, &innerStream, options, false);
cs1.write("a", 1);
EXPECT_EQ(175, g_newIvDoesNotChangeIv_buffer[0]);

112
src/test/unittests/synergy/GenericArgsParsingTests.cpp
View File

@@ -41,68 +41,68 @@ showMockVersion()
g_versionShowed = true;
}
TEST(CGenericArgsParsingTests, parseGenericArgs_logLevelCmd_setLogLevel)
TEST(GenericArgsParsingTests, parseGenericArgs_logLevelCmd_setLogLevel)
{
int i = 1;
const int argc = 3;
const char* kLogLevelCmd[argc] = { "stub", "--debug", "DEBUG" };
CArgParser argParser(NULL);
CArgsBase argsBase;
ArgParser argParser(NULL);
ArgsBase argsBase;
argParser.setArgsBase(argsBase);
argParser.parseGenericArgs(argc, kLogLevelCmd, i);
CString logFilter(argsBase.m_logFilter);
String logFilter(argsBase.m_logFilter);
EXPECT_EQ("DEBUG", logFilter);
EXPECT_EQ(2, i);
}
TEST(CGenericArgsParsingTests, parseGenericArgs_logFileCmd_saveLogFilename)
TEST(GenericArgsParsingTests, parseGenericArgs_logFileCmd_saveLogFilename)
{
int i = 1;
const int argc = 3;
const char* kLogFileCmd[argc] = { "stub", "--log", "mock_filename" };
CArgParser argParser(NULL);
CArgsBase argsBase;
ArgParser argParser(NULL);
ArgsBase argsBase;
argParser.setArgsBase(argsBase);
argParser.parseGenericArgs(argc, kLogFileCmd, i);
CString logFile(argsBase.m_logFile);
String logFile(argsBase.m_logFile);
EXPECT_EQ("mock_filename", logFile);
EXPECT_EQ(2, i);
}
TEST(CGenericArgsParsingTests, parseGenericArgs_logFileCmdWithSpace_saveLogFilename)
TEST(GenericArgsParsingTests, parseGenericArgs_logFileCmdWithSpace_saveLogFilename)
{
int i = 1;
const int argc = 3;
const char* kLogFileCmdWithSpace[argc] = { "stub", "--log", "mo ck_filename" };
CArgParser argParser(NULL);
CArgsBase argsBase;
ArgParser argParser(NULL);
ArgsBase argsBase;
argParser.setArgsBase(argsBase);
argParser.parseGenericArgs(argc, kLogFileCmdWithSpace, i);
CString logFile(argsBase.m_logFile);
String logFile(argsBase.m_logFile);
EXPECT_EQ("mo ck_filename", logFile);
EXPECT_EQ(2, i);
}
TEST(CGenericArgsParsingTests, parseGenericArgs_noDeamonCmd_daemonFalse)
TEST(GenericArgsParsingTests, parseGenericArgs_noDeamonCmd_daemonFalse)
{
int i = 1;
const int argc = 2;
const char* kNoDeamonCmd[argc] = { "stub", "-f" };
CArgParser argParser(NULL);
CArgsBase argsBase;
ArgParser argParser(NULL);
ArgsBase argsBase;
argParser.setArgsBase(argsBase);
argParser.parseGenericArgs(argc, kNoDeamonCmd, i);
@@ -111,14 +111,14 @@ TEST(CGenericArgsParsingTests, parseGenericArgs_noDeamonCmd_daemonFalse)
EXPECT_EQ(1, i);
}
TEST(CGenericArgsParsingTests, parseGenericArgs_deamonCmd_daemonTrue)
TEST(GenericArgsParsingTests, parseGenericArgs_deamonCmd_daemonTrue)
{
int i = 1;
const int argc = 2;
const char* kDeamonCmd[argc] = { "stub", "--daemon" };
CArgParser argParser(NULL);
CArgsBase argsBase;
ArgParser argParser(NULL);
ArgsBase argsBase;
argParser.setArgsBase(argsBase);
argParser.parseGenericArgs(argc, kDeamonCmd, i);
@@ -127,14 +127,14 @@ TEST(CGenericArgsParsingTests, parseGenericArgs_deamonCmd_daemonTrue)
EXPECT_EQ(1, i);
}
TEST(CGenericArgsParsingTests, parseGenericArgs_nameCmd_saveName)
TEST(GenericArgsParsingTests, parseGenericArgs_nameCmd_saveName)
{
int i = 1;
const int argc = 3;
const char* kNameCmd[argc] = { "stub", "--name", "mock" };
CArgParser argParser(NULL);
CArgsBase argsBase;
ArgParser argParser(NULL);
ArgsBase argsBase;
argParser.setArgsBase(argsBase);
argParser.parseGenericArgs(argc, kNameCmd, i);
@@ -143,14 +143,14 @@ TEST(CGenericArgsParsingTests, parseGenericArgs_nameCmd_saveName)
EXPECT_EQ(2, i);
}
TEST(CGenericArgsParsingTests, parseGenericArgs_noRestartCmd_restartFalse)
TEST(GenericArgsParsingTests, parseGenericArgs_noRestartCmd_restartFalse)
{
int i = 1;
const int argc = 2;
const char* kNoRestartCmd[argc] = { "stub", "--no-restart" };
CArgParser argParser(NULL);
CArgsBase argsBase;
ArgParser argParser(NULL);
ArgsBase argsBase;
argParser.setArgsBase(argsBase);
argParser.parseGenericArgs(argc, kNoRestartCmd, i);
@@ -159,14 +159,14 @@ TEST(CGenericArgsParsingTests, parseGenericArgs_noRestartCmd_restartFalse)
EXPECT_EQ(1, i);
}
TEST(CGenericArgsParsingTests, parseGenericArgs_restartCmd_restartTrue)
TEST(GenericArgsParsingTests, parseGenericArgs_restartCmd_restartTrue)
{
int i = 1;
const int argc = 2;
const char* kRestartCmd[argc] = { "stub", "--restart" };
CArgParser argParser(NULL);
CArgsBase argsBase;
ArgParser argParser(NULL);
ArgsBase argsBase;
argParser.setArgsBase(argsBase);
argParser.parseGenericArgs(argc, kRestartCmd, i);
@@ -175,14 +175,14 @@ TEST(CGenericArgsParsingTests, parseGenericArgs_restartCmd_restartTrue)
EXPECT_EQ(1, i);
}
TEST(CGenericArgsParsingTests, parseGenericArgs_backendCmd_backendTrue)
TEST(GenericArgsParsingTests, parseGenericArgs_backendCmd_backendTrue)
{
int i = 1;
const int argc = 2;
const char* kBackendCmd[argc] = { "stub", "-z" };
CArgParser argParser(NULL);
CArgsBase argsBase;
ArgParser argParser(NULL);
ArgsBase argsBase;
argParser.setArgsBase(argsBase);
argParser.parseGenericArgs(argc, kBackendCmd, i);
@@ -191,14 +191,14 @@ TEST(CGenericArgsParsingTests, parseGenericArgs_backendCmd_backendTrue)
EXPECT_EQ(1, i);
}
TEST(CGenericArgsParsingTests, parseGenericArgs_noHookCmd_noHookTrue)
TEST(GenericArgsParsingTests, parseGenericArgs_noHookCmd_noHookTrue)
{
int i = 1;
const int argc = 2;
const char* kNoHookCmd[argc] = { "stub", "--no-hooks" };
CArgParser argParser(NULL);
CArgsBase argsBase;
ArgParser argParser(NULL);
ArgsBase argsBase;
argParser.setArgsBase(argsBase);
argParser.parseGenericArgs(argc, kNoHookCmd, i);
@@ -207,16 +207,16 @@ TEST(CGenericArgsParsingTests, parseGenericArgs_noHookCmd_noHookTrue)
EXPECT_EQ(1, i);
}
TEST(CGenericArgsParsingTests, parseGenericArgs_helpCmd_showHelp)
TEST(GenericArgsParsingTests, parseGenericArgs_helpCmd_showHelp)
{
g_helpShowed = false;
int i = 1;
const int argc = 2;
const char* kHelpCmd[argc] = { "stub", "--help" };
NiceMock<CMockApp> app;
CArgParser argParser(&app);
CArgsBase argsBase;
NiceMock<MockApp> app;
ArgParser argParser(&app);
ArgsBase argsBase;
argParser.setArgsBase(argsBase);
ON_CALL(app, help()).WillByDefault(Invoke(showMockHelp));
@@ -227,16 +227,16 @@ TEST(CGenericArgsParsingTests, parseGenericArgs_helpCmd_showHelp)
}
TEST(CGenericArgsParsingTests, parseGenericArgs_versionCmd_showVersion)
TEST(GenericArgsParsingTests, parseGenericArgs_versionCmd_showVersion)
{
g_versionShowed = false;
int i = 1;
const int argc = 2;
const char* kVersionCmd[argc] = { "stub", "--version" };
NiceMock<CMockApp> app;
CArgParser argParser(&app);
CArgsBase argsBase;
NiceMock<MockApp> app;
ArgParser argParser(&app);
ArgsBase argsBase;
argParser.setArgsBase(argsBase);
ON_CALL(app, version()).WillByDefault(Invoke(showMockVersion));
@@ -246,14 +246,14 @@ TEST(CGenericArgsParsingTests, parseGenericArgs_versionCmd_showVersion)
EXPECT_EQ(1, i);
}
TEST(CGenericArgsParsingTests, parseGenericArgs_noTrayCmd_disableTrayTrue)
TEST(GenericArgsParsingTests, parseGenericArgs_noTrayCmd_disableTrayTrue)
{
int i = 1;
const int argc = 2;
const char* kNoTrayCmd[argc] = { "stub", "--no-tray" };
CArgParser argParser(NULL);
CArgsBase argsBase;
ArgParser argParser(NULL);
ArgsBase argsBase;
argParser.setArgsBase(argsBase);
argParser.parseGenericArgs(argc, kNoTrayCmd, i);
@@ -262,14 +262,14 @@ TEST(CGenericArgsParsingTests, parseGenericArgs_noTrayCmd_disableTrayTrue)
EXPECT_EQ(1, i);
}
TEST(CGenericArgsParsingTests, parseGenericArgs_ipcCmd_enableIpcTrue)
TEST(GenericArgsParsingTests, parseGenericArgs_ipcCmd_enableIpcTrue)
{
int i = 1;
const int argc = 2;
const char* kIpcCmd[argc] = { "stub", "--ipc" };
CArgParser argParser(NULL);
CArgsBase argsBase;
ArgParser argParser(NULL);
ArgsBase argsBase;
argParser.setArgsBase(argsBase);
argParser.parseGenericArgs(argc, kIpcCmd, i);
@@ -278,14 +278,14 @@ TEST(CGenericArgsParsingTests, parseGenericArgs_ipcCmd_enableIpcTrue)
EXPECT_EQ(1, i);
}
TEST(CGenericArgsParsingTests, parseGenericArgs_cryptoPassCmd_savePassword)
TEST(GenericArgsParsingTests, parseGenericArgs_cryptoPassCmd_savePassword)
{
int i = 1;
const int argc = 3;
const char* kCryptoPassCmd[argc] = { "stub", "--crypto-pass", "mock_password" };
CArgParser argParser(NULL);
CArgsBase argsBase;
ArgParser argParser(NULL);
ArgsBase argsBase;
argParser.setArgsBase(argsBase);
argParser.parseGenericArgs(argc, kCryptoPassCmd, i);
@@ -296,14 +296,14 @@ TEST(CGenericArgsParsingTests, parseGenericArgs_cryptoPassCmd_savePassword)
}
#ifndef WINAPI_XWINDOWS
TEST(CGenericArgsParsingTests, parseGenericArgs_dragDropCmdOnNonLinux_enableDragDropTrue)
TEST(GenericArgsParsingTests, parseGenericArgs_dragDropCmdOnNonLinux_enableDragDropTrue)
{
int i = 1;
const int argc = 2;
const char* kDragDropCmd[argc] = { "stub", "--enable-drag-drop" };
CArgParser argParser(NULL);
CArgsBase argsBase;
ArgParser argParser(NULL);
ArgsBase argsBase;
argParser.setArgsBase(argsBase);
argParser.parseGenericArgs(argc, kDragDropCmd, i);
@@ -314,14 +314,14 @@ TEST(CGenericArgsParsingTests, parseGenericArgs_dragDropCmdOnNonLinux_enableDrag
#endif
#ifdef WINAPI_XWINDOWS
TEST(CGenericArgsParsingTests, parseGenericArgs_dragDropCmdOnLinux_enableDragDropFalse)
TEST(GenericArgsParsingTests, parseGenericArgs_dragDropCmdOnLinux_enableDragDropFalse)
{
int i = 1;
const int argc = 2;
const char* kDragDropCmd[argc] = { "stub", "--enable-drag-drop" };
CArgParser argParser(NULL);
CArgsBase argsBase;
ArgParser argParser(NULL);
ArgsBase argsBase;
argParser.setArgsBase(argsBase);
argParser.parseGenericArgs(argc, kDragDropCmd, i);

248
src/test/unittests/synergy/KeyStateTests.cpp
View File

@@ -31,44 +31,44 @@ using ::testing::Return;
using ::testing::ReturnRef;
using ::testing::SaveArg;
TEST(CKeyStateTests, onKey_aKeyDown_keyStateOne)
TEST(KeyStateTests, onKey_aKeyDown_keyStateOne)
{
CMockKeyMap keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
MockKeyMap keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
keyState.onKey(1, true, KeyModifierAlt);
EXPECT_EQ(1, keyState.getKeyState(1));
}
TEST(CKeyStateTests, onKey_aKeyUp_keyStateZero)
TEST(KeyStateTests, onKey_aKeyUp_keyStateZero)
{
CMockKeyMap keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
MockKeyMap keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
keyState.onKey(1, false, KeyModifierAlt);
EXPECT_EQ(0, keyState.getKeyState(1));
}
TEST(CKeyStateTests, onKey_invalidKey_keyStateZero)
TEST(KeyStateTests, onKey_invalidKey_keyStateZero)
{
CMockKeyMap keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
MockKeyMap keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
keyState.onKey(0, true, KeyModifierAlt);
EXPECT_EQ(0, keyState.getKeyState(0));
}
TEST(CKeyStateTests, sendKeyEvent_halfDuplexAndRepeat_addEventNotCalled)
TEST(KeyStateTests, sendKeyEvent_halfDuplexAndRepeat_addEventNotCalled)
{
NiceMock<CMockKeyMap> keyMap;
NiceMock<CMockEventQueue> eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
NiceMock<MockKeyMap> keyMap;
NiceMock<MockEventQueue> eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
ON_CALL(keyMap, isHalfDuplex(_, _)).WillByDefault(Return(true));
@@ -77,11 +77,11 @@ TEST(CKeyStateTests, sendKeyEvent_halfDuplexAndRepeat_addEventNotCalled)
keyState.sendKeyEvent(NULL, false, true, kKeyCapsLock, 0, 0, 0);
}
TEST(CKeyStateTests, sendKeyEvent_halfDuplex_addEventCalledTwice)
TEST(KeyStateTests, sendKeyEvent_halfDuplex_addEventCalledTwice)
{
NiceMock<CMockKeyMap> keyMap;
NiceMock<CMockEventQueue> eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
NiceMock<MockKeyMap> keyMap;
NiceMock<MockEventQueue> eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
IKeyStateEvents keyStateEvents;
keyStateEvents.setEvents(&eventQueue);
@@ -93,11 +93,11 @@ TEST(CKeyStateTests, sendKeyEvent_halfDuplex_addEventCalledTwice)
keyState.sendKeyEvent(NULL, false, false, kKeyCapsLock, 0, 0, 0);
}
TEST(CKeyStateTests, sendKeyEvent_keyRepeat_addEventCalledOnce)
TEST(KeyStateTests, sendKeyEvent_keyRepeat_addEventCalledOnce)
{
NiceMock<CMockKeyMap> keyMap;
NiceMock<CMockEventQueue> eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
NiceMock<MockKeyMap> keyMap;
NiceMock<MockEventQueue> eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
IKeyStateEvents keyStateEvents;
keyStateEvents.setEvents(&eventQueue);
@@ -108,11 +108,11 @@ TEST(CKeyStateTests, sendKeyEvent_keyRepeat_addEventCalledOnce)
keyState.sendKeyEvent(NULL, false, true, 1, 0, 0, 0);
}
TEST(CKeyStateTests, sendKeyEvent_keyDown_addEventCalledOnce)
TEST(KeyStateTests, sendKeyEvent_keyDown_addEventCalledOnce)
{
NiceMock<CMockKeyMap> keyMap;
NiceMock<CMockEventQueue> eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
NiceMock<MockKeyMap> keyMap;
NiceMock<MockEventQueue> eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
IKeyStateEvents keyStateEvents;
keyStateEvents.setEvents(&eventQueue);
@@ -123,11 +123,11 @@ TEST(CKeyStateTests, sendKeyEvent_keyDown_addEventCalledOnce)
keyState.sendKeyEvent(NULL, true, false, 1, 0, 0, 0);
}
TEST(CKeyStateTests, sendKeyEvent_keyUp_addEventCalledOnce)
TEST(KeyStateTests, sendKeyEvent_keyUp_addEventCalledOnce)
{
NiceMock<CMockKeyMap> keyMap;
NiceMock<CMockEventQueue> eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
NiceMock<MockKeyMap> keyMap;
NiceMock<MockEventQueue> eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
IKeyStateEvents keyStateEvents;
keyStateEvents.setEvents(&eventQueue);
@@ -138,11 +138,11 @@ TEST(CKeyStateTests, sendKeyEvent_keyUp_addEventCalledOnce)
keyState.sendKeyEvent(NULL, false, false, 1, 0, 0, 0);
}
TEST(CKeyStateTests, updateKeyMap_mockKeyMap_keyMapGotMock)
TEST(KeyStateTests, updateKeyMap_mockKeyMap_keyMapGotMock)
{
NiceMock<CMockKeyMap> keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
NiceMock<MockKeyMap> keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
// key map member gets a new key map via swap()
EXPECT_CALL(keyMap, swap(_));
@@ -150,11 +150,11 @@ TEST(CKeyStateTests, updateKeyMap_mockKeyMap_keyMapGotMock)
keyState.updateKeyMap();
}
TEST(CKeyStateTests, updateKeyState_pollInsertsSingleKey_keyIsDown)
TEST(KeyStateTests, updateKeyState_pollInsertsSingleKey_keyIsDown)
{
NiceMock<CMockKeyMap> keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
NiceMock<MockKeyMap> keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
ON_CALL(keyState, pollPressedKeys(_)).WillByDefault(Invoke(stubPollPressedKeys));
keyState.updateKeyState();
@@ -163,11 +163,11 @@ TEST(CKeyStateTests, updateKeyState_pollInsertsSingleKey_keyIsDown)
ASSERT_TRUE(actual);
}
TEST(CKeyStateTests, updateKeyState_pollDoesNothing_keyNotSet)
TEST(KeyStateTests, updateKeyState_pollDoesNothing_keyNotSet)
{
NiceMock<CMockKeyMap> keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
NiceMock<MockKeyMap> keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
keyState.updateKeyState();
@@ -175,11 +175,11 @@ TEST(CKeyStateTests, updateKeyState_pollDoesNothing_keyNotSet)
ASSERT_FALSE(actual);
}
TEST(CKeyStateTests, updateKeyState_activeModifiers_maskSet)
TEST(KeyStateTests, updateKeyState_activeModifiers_maskSet)
{
NiceMock<CMockKeyMap> keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
NiceMock<MockKeyMap> keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
ON_CALL(keyState, pollActiveModifiers()).WillByDefault(Return(KeyModifierAlt));
keyState.updateKeyState();
@@ -188,11 +188,11 @@ TEST(CKeyStateTests, updateKeyState_activeModifiers_maskSet)
ASSERT_EQ(KeyModifierAlt, actual);
}
TEST(CKeyStateTests, updateKeyState_activeModifiers_maskNotSet)
TEST(KeyStateTests, updateKeyState_activeModifiers_maskNotSet)
{
NiceMock<CMockKeyMap> keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
NiceMock<MockKeyMap> keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
keyState.updateKeyState();
@@ -200,11 +200,11 @@ TEST(CKeyStateTests, updateKeyState_activeModifiers_maskNotSet)
ASSERT_EQ(0, actual);
}
TEST(CKeyStateTests, updateKeyState_activeModifiers_keyMapGotModifers)
TEST(KeyStateTests, updateKeyState_activeModifiers_keyMapGotModifers)
{
CMockKeyMap keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
MockKeyMap keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
ON_CALL(keyState, pollActiveModifiers()).WillByDefault(Return(1));
ON_CALL(keyMap, foreachKey(_, _)).WillByDefault(Invoke(assertMaskIsOne));
@@ -214,44 +214,44 @@ TEST(CKeyStateTests, updateKeyState_activeModifiers_keyMapGotModifers)
keyState.updateKeyState();
}
TEST(CKeyStateTests, setHalfDuplexMask_capsLock_halfDuplexCapsLockAdded)
TEST(KeyStateTests, setHalfDuplexMask_capsLock_halfDuplexCapsLockAdded)
{
CMockKeyMap keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
MockKeyMap keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
EXPECT_CALL(keyMap, addHalfDuplexModifier(kKeyCapsLock));
keyState.setHalfDuplexMask(KeyModifierCapsLock);
}
TEST(CKeyStateTests, setHalfDuplexMask_numLock_halfDuplexNumLockAdded)
TEST(KeyStateTests, setHalfDuplexMask_numLock_halfDuplexNumLockAdded)
{
CMockKeyMap keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
MockKeyMap keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
EXPECT_CALL(keyMap, addHalfDuplexModifier(kKeyNumLock));
keyState.setHalfDuplexMask(KeyModifierNumLock);
}
TEST(CKeyStateTests, setHalfDuplexMask_scrollLock_halfDuplexScollLockAdded)
TEST(KeyStateTests, setHalfDuplexMask_scrollLock_halfDuplexScollLockAdded)
{
CMockKeyMap keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
MockKeyMap keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
EXPECT_CALL(keyMap, addHalfDuplexModifier(kKeyScrollLock));
keyState.setHalfDuplexMask(KeyModifierScrollLock);
}
TEST(CKeyStateTests, fakeKeyDown_serverKeyAlreadyDown_fakeKeyCalledTwice)
TEST(KeyStateTests, fakeKeyDown_serverKeyAlreadyDown_fakeKeyCalledTwice)
{
NiceMock<CMockKeyMap> keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
NiceMock<MockKeyMap> keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
s_stubKeyItem.m_client = 0;
s_stubKeyItem.m_button = 1;
ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Invoke(stubMapKey));
@@ -265,22 +265,22 @@ TEST(CKeyStateTests, fakeKeyDown_serverKeyAlreadyDown_fakeKeyCalledTwice)
keyState.fakeKeyDown(1, 0, 0);
}
TEST(CKeyStateTests, fakeKeyDown_isIgnoredKey_fakeKeyNotCalled)
TEST(KeyStateTests, fakeKeyDown_isIgnoredKey_fakeKeyNotCalled)
{
CMockKeyMap keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
MockKeyMap keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
EXPECT_CALL(keyState, fakeKey(_)).Times(0);
keyState.fakeKeyDown(kKeyCapsLock, 0, 0);
}
TEST(CKeyStateTests, fakeKeyDown_mapReturnsKeystrokes_fakeKeyCalled)
TEST(KeyStateTests, fakeKeyDown_mapReturnsKeystrokes_fakeKeyCalled)
{
NiceMock<CMockKeyMap> keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
NiceMock<MockKeyMap> keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
s_stubKeyItem.m_button = 0;
s_stubKeyItem.m_client = 0;
ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Invoke(stubMapKey));
@@ -290,32 +290,32 @@ TEST(CKeyStateTests, fakeKeyDown_mapReturnsKeystrokes_fakeKeyCalled)
keyState.fakeKeyDown(1, 0, 0);
}
TEST(CKeyStateTests, fakeKeyRepeat_invalidKey_returnsFalse)
TEST(KeyStateTests, fakeKeyRepeat_invalidKey_returnsFalse)
{
CMockKeyMap keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
MockKeyMap keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
bool actual = keyState.fakeKeyRepeat(0, 0, 0, 0);
ASSERT_FALSE(actual);
}
TEST(CKeyStateTests, fakeKeyRepeat_nullKey_returnsFalse)
TEST(KeyStateTests, fakeKeyRepeat_nullKey_returnsFalse)
{
NiceMock<CMockKeyMap> keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
NiceMock<MockKeyMap> keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
// set the key to down (we need to make mapKey return a valid key to do this).
CKeyMap::KeyItem keyItem;
synergy::KeyMap::KeyItem keyItem;
keyItem.m_client = 0;
keyItem.m_button = 1;
ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Return(&keyItem));
keyState.fakeKeyDown(1, 0, 0);
// change mapKey to return NULL so that fakeKeyRepeat exits early.
CKeyMap::KeyItem* nullKeyItem = NULL;
synergy::KeyMap::KeyItem* nullKeyItem = NULL;
ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Return(nullKeyItem));
bool actual = keyState.fakeKeyRepeat(1, 0, 0, 0);
@@ -323,14 +323,14 @@ TEST(CKeyStateTests, fakeKeyRepeat_nullKey_returnsFalse)
ASSERT_FALSE(actual);
}
TEST(CKeyStateTests, fakeKeyRepeat_invalidButton_returnsFalse)
TEST(KeyStateTests, fakeKeyRepeat_invalidButton_returnsFalse)
{
NiceMock<CMockKeyMap> keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
NiceMock<MockKeyMap> keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
// set the key to down (we need to make mapKey return a valid key to do this).
CKeyMap::KeyItem keyItem;
synergy::KeyMap::KeyItem keyItem;
keyItem.m_client = 0;
keyItem.m_button = 1; // set to 1 to make fakeKeyDown work.
ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Return(&keyItem));
@@ -345,13 +345,13 @@ TEST(CKeyStateTests, fakeKeyRepeat_invalidButton_returnsFalse)
ASSERT_FALSE(actual);
}
TEST(CKeyStateTests, fakeKeyRepeat_validKey_returnsTrue)
TEST(KeyStateTests, fakeKeyRepeat_validKey_returnsTrue)
{
NiceMock<CMockKeyMap> keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
NiceMock<MockKeyMap> keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
s_stubKeyItem.m_client = 0;
s_stubKeystroke.m_type = CKeyMap::Keystroke::kButton;
s_stubKeystroke.m_type = synergy::KeyMap::Keystroke::kButton;
s_stubKeystroke.m_data.m_button.m_button = 2;
// set the button to 1 for fakeKeyDown call
@@ -368,22 +368,22 @@ TEST(CKeyStateTests, fakeKeyRepeat_validKey_returnsTrue)
ASSERT_TRUE(actual);
}
TEST(CKeyStateTests, fakeKeyUp_buttonNotDown_returnsFalse)
TEST(KeyStateTests, fakeKeyUp_buttonNotDown_returnsFalse)
{
CMockKeyMap keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
MockKeyMap keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
bool actual = keyState.fakeKeyUp(0);
ASSERT_FALSE(actual);
}
TEST(CKeyStateTests, fakeKeyUp_buttonAlreadyDown_returnsTrue)
TEST(KeyStateTests, fakeKeyUp_buttonAlreadyDown_returnsTrue)
{
NiceMock<CMockKeyMap> keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
NiceMock<MockKeyMap> keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
// press alt down so we get full coverage.
ON_CALL(keyState, pollActiveModifiers()).WillByDefault(Return(KeyModifierAlt));
@@ -400,11 +400,11 @@ TEST(CKeyStateTests, fakeKeyUp_buttonAlreadyDown_returnsTrue)
ASSERT_TRUE(actual);
}
TEST(CKeyStateTests, fakeAllKeysUp_keysWereDown_keysAreUp)
TEST(KeyStateTests, fakeAllKeysUp_keysWereDown_keysAreUp)
{
NiceMock<CMockKeyMap> keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
NiceMock<MockKeyMap> keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
// press button 1 down.
s_stubKeyItem.m_button = 1;
@@ -418,11 +418,11 @@ TEST(CKeyStateTests, fakeAllKeysUp_keysWereDown_keysAreUp)
ASSERT_FALSE(actual);
}
TEST(CKeyStateTests, isKeyDown_keyDown_returnsTrue)
TEST(KeyStateTests, isKeyDown_keyDown_returnsTrue)
{
NiceMock<CMockKeyMap> keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
NiceMock<MockKeyMap> keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
// press button 1 down.
s_stubKeyItem.m_button = 1;
@@ -435,11 +435,11 @@ TEST(CKeyStateTests, isKeyDown_keyDown_returnsTrue)
ASSERT_TRUE(actual);
}
TEST(CKeyStateTests, isKeyDown_noKeysDown_returnsFalse)
TEST(KeyStateTests, isKeyDown_noKeysDown_returnsFalse)
{
CMockKeyMap keyMap;
CMockEventQueue eventQueue;
CKeyStateImpl keyState(eventQueue, keyMap);
MockKeyMap keyMap;
MockEventQueue eventQueue;
KeyStateImpl keyState(eventQueue, keyMap);
// method under test
bool actual = keyState.isKeyDown(1);
@@ -456,13 +456,13 @@ stubPollPressedKeys(IKeyState::KeyButtonSet& pressedKeys)
void
assertMaskIsOne(ForeachKeyCallback cb, void* userData)
{
ASSERT_EQ(1, ((CKeyState::CAddActiveModifierContext*)userData)->m_mask);
ASSERT_EQ(1, ((KeyState::AddActiveModifierContext*)userData)->m_mask);
}
const CKeyMap::KeyItem*
const synergy::KeyMap::KeyItem*
stubMapKey(
CKeyMap::Keystrokes& keys, KeyID id, SInt32 group,
CKeyMap::ModifierToKeys& activeModifiers,
synergy::KeyMap::Keystrokes& keys, KeyID id, SInt32 group,
synergy::KeyMap::ModifierToKeys& activeModifiers,
KeyModifierMask& currentState,
KeyModifierMask desiredMask,
bool isAutoRepeat)

32
src/test/unittests/synergy/KeyStateTests.h
View File

@@ -22,38 +22,38 @@
#include "test/global/gmock.h"
class CMockKeyMap;
class CMockEventQueue;
class MockKeyMap;
class MockEventQueue;
// NOTE: do not mock methods that are not pure virtual. this mock exists only
// to provide an implementation of the CKeyState abstract class.
class CMockKeyState : public CKeyState
// to provide an implementation of the KeyState abstract class.
class MockKeyState : public KeyState
{
public:
CMockKeyState(const CMockEventQueue& eventQueue) :
CKeyState((IEventQueue*)&eventQueue)
MockKeyState(const MockEventQueue& eventQueue) :
KeyState((IEventQueue*)&eventQueue)
{
}
CMockKeyState(const CMockEventQueue& eventQueue, const CMockKeyMap& keyMap) :
CKeyState((IEventQueue*)&eventQueue, (CKeyMap&)keyMap)
MockKeyState(const MockEventQueue& eventQueue, const MockKeyMap& keyMap) :
KeyState((IEventQueue*)&eventQueue, (synergy::KeyMap&)keyMap)
{
}
MOCK_CONST_METHOD0(pollActiveGroup, SInt32());
MOCK_CONST_METHOD0(pollActiveModifiers, KeyModifierMask());
MOCK_METHOD0(fakeCtrlAltDel, bool());
MOCK_METHOD1(getKeyMap, void(CKeyMap&));
MOCK_METHOD1(getKeyMap, void(synergy::KeyMap&));
MOCK_METHOD1(fakeKey, void(const Keystroke&));
MOCK_CONST_METHOD1(pollPressedKeys, void(KeyButtonSet&));
};
typedef ::testing::NiceMock<CMockKeyState> CKeyStateImpl;
typedef ::testing::NiceMock<MockKeyState> KeyStateImpl;
typedef UInt32 KeyID;
typedef void (*ForeachKeyCallback)(
KeyID, SInt32 group, CKeyMap::KeyItem&, void* userData);
KeyID, SInt32 group, synergy::KeyMap::KeyItem&, void* userData);
void
stubPollPressedKeys(IKeyState::KeyButtonSet& pressedKeys);
@@ -61,13 +61,13 @@ stubPollPressedKeys(IKeyState::KeyButtonSet& pressedKeys);
void
assertMaskIsOne(ForeachKeyCallback cb, void* userData);
const CKeyMap::KeyItem*
const synergy::KeyMap::KeyItem*
stubMapKey(
CKeyMap::Keystrokes& keys, KeyID id, SInt32 group,
CKeyMap::ModifierToKeys& activeModifiers,
synergy::KeyMap::Keystrokes& keys, KeyID id, SInt32 group,
synergy::KeyMap::ModifierToKeys& activeModifiers,
KeyModifierMask& currentState,
KeyModifierMask desiredMask,
bool isAutoRepeat);
CKeyMap::Keystroke s_stubKeystroke(1, false, false);
CKeyMap::KeyItem s_stubKeyItem;
synergy::KeyMap::Keystroke s_stubKeystroke(1, false, false);
synergy::KeyMap::KeyItem s_stubKeyItem;

12
src/test/unittests/synergy/ServerArgsParsingTests.cpp
View File

@@ -37,12 +37,12 @@ server_stubCheckUnexpectedArgs()
return false;
}
TEST(CServerArgsParsingTests, parseServerArgs_addressArg_setSynergyAddress)
TEST(ServerArgsParsingTests, parseServerArgs_addressArg_setSynergyAddress)
{
NiceMock<CMockArgParser> argParser;
NiceMock<MockArgParser> argParser;
ON_CALL(argParser, parseGenericArgs(_, _, _)).WillByDefault(Invoke(server_stubParseGenericArgs));
ON_CALL(argParser, checkUnexpectedArgs()).WillByDefault(Invoke(server_stubCheckUnexpectedArgs));
CServerArgs serverArgs;
ServerArgs serverArgs;
const int argc = 3;
const char* kAddressCmd[argc] = { "stub", "--address", "mock_address" };
@@ -51,12 +51,12 @@ TEST(CServerArgsParsingTests, parseServerArgs_addressArg_setSynergyAddress)
EXPECT_EQ("mock_address", serverArgs.m_synergyAddress);
}
TEST(CServerArgsParsingTests, parseServerArgs_configArg_setConfigFile)
TEST(ServerArgsParsingTests, parseServerArgs_configArg_setConfigFile)
{
NiceMock<CMockArgParser> argParser;
NiceMock<MockArgParser> argParser;
ON_CALL(argParser, parseGenericArgs(_, _, _)).WillByDefault(Invoke(server_stubParseGenericArgs));
ON_CALL(argParser, checkUnexpectedArgs()).WillByDefault(Invoke(server_stubCheckUnexpectedArgs));
CServerArgs serverArgs;
ServerArgs serverArgs;
const int argc = 3;
const char* kConfigCmd[argc] = { "stub", "--config", "mock_configFile" };