moving 1.4 to trunk

src/test/unittests/CMakeLists.txt

@@ -0,0 +1,63 @@
+# synergy -- mouse and keyboard sharing utility
+# Copyright (C) 2009 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
+# 
+# This package is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# found in the file COPYING that should have accompanied this file.
+# 
+# This package is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+set(h
+	synergy/CKeyStateTests.h
+	synergy/CMockEventQueue.h
+	synergy/CMockKeyMap.h
+	client/CMockClient.h
+	io/CMockStream.h
+)
+
+set(src
+	${h}
+	Main.cpp
+	synergy/CClipboardTests.cpp
+	synergy/CKeyStateTests.cpp
+	client/CServerProxyTests.cpp
+)
+
+set(inc
+	../../lib/arch
+	../../lib/base
+	../../lib/client
+	../../lib/common
+	../../lib/io
+	../../lib/mt
+	../../lib/net
+	../../lib/platform
+	../../lib/synergy
+	../../../tools/gtest-1.6.0/include
+	../../../tools/gmock-1.6.0/include
+	io
+	synergy
+)
+
+if (UNIX)
+	list(APPEND inc
+		../../..
+	)
+endif()
+
+if (WIN32)
+	if (GAME_DEVICE_SUPPORT)
+		link_directories("$ENV{DXSDK_DIR}/Lib/x86")
+	endif()
+endif()
+
+include_directories(${inc})
+add_executable(unittests ${src})
+target_link_libraries(unittests
+	arch base client common io net platform server synergy mt gtest gmock ${libs})

src/test/unittests/Main.cpp

@@ -0,0 +1,39 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ * 
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <gtest/gtest.h>
+#include "CArch.h"
+#include "CLog.h"
+
+#if SYSAPI_WIN32
+#include "CArchMiscWindows.h"
+#endif
+
+int
+main(int argc, char **argv)
+{
+#if SYSAPI_WIN32
+	// HACK: shouldn't be needed, but logging fails without this.
+	CArchMiscWindows::setInstanceWin32(GetModuleHandle(NULL));
+#endif
+
+	CLOG->setFilter(kDEBUG2);
+
+	testing::InitGoogleTest(&argc, argv);
+
+	return RUN_ALL_TESTS();
+}

src/test/unittests/client/CMockClient.h

@@ -0,0 +1,30 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
+ *
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ *
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <gmock/gmock.h>
+#include "CClient.h"
+
+class IEventQueue;
+
+class CMockClient : public CClient
+{
+public:
+	CMockClient(IEventQueue& eventQueue) : CClient(eventQueue) { m_mock = true; }
+	MOCK_METHOD2(mouseMove, void(SInt32, SInt32));
+};

src/test/unittests/client/CServerProxyTests.cpp

@@ -0,0 +1,90 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
+ *
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ *
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <gtest/gtest.h>
+
+#define TEST_ENV
+#include "Global.h"
+
+#include "CServerProxy.h"
+#include "CMockClient.h"
+#include "CMockStream.h"
+#include "CMockEventQueue.h"
+#include "ProtocolTypes.h"
+
+using ::testing::_;
+using ::testing::Invoke;
+using ::testing::NiceMock;
+using ::testing::AnyNumber;
+
+int streamReads = 0;
+
+UInt32
+streamRead(void* buffer, UInt32 n);
+
+// TODO: fix linking in windows (works in unix for some reason).
+#if 0
+TEST(CServerProxyTests, parseMessage_mouseMove_valuesCorrect)
+{
+	NiceMock<CMockEventQueue> eventQueue;
+	CMockClient client(eventQueue);
+	CMockStream stream(eventQueue);
+
+	ON_CALL(stream, read(_, _)).WillByDefault(Invoke(streamRead));
+	EXPECT_CALL(stream, read(_, _)).Times(4);
+	EXPECT_CALL(stream, write(_, _)).Times(1);
+	EXPECT_CALL(stream, isReady()).Times(1);
+	EXPECT_CALL(stream, getEventTarget()).Times(AnyNumber());
+
+	CServerProxy serverProxy(&client, &stream, eventQueue);
+
+	// skip handshake, go straight to normal parser.
+	serverProxy.m_parser = &CServerProxy::parseMessage;
+
+	// assert
+	EXPECT_CALL(client, mouseMove(10, 20));
+
+	serverProxy.handleData(NULL, NULL);
+}
+#endif
+
+UInt32
+streamRead(void* buffer, UInt32 n)
+{
+	streamReads++;
+	UInt8* code = (UInt8*)buffer;
+
+	if (streamReads == 1) {
+		code[0] = 'D';
+		code[1] = 'M';
+		code[2] = 'M';
+		code[3] = 'V';
+		return 4;
+	}
+	else if (streamReads == 2) {
+		code[0] = 0;
+		code[1] = 10;
+		return 2;
+	}
+	else if (streamReads == 3) {
+		code[0] = 0;
+		code[1] = 20;
+		return 2;
+	}
+
+	return 0;
+}

src/test/unittests/io/CMockStream.h

@@ -0,0 +1,38 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
+ *
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ *
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <gmock/gmock.h>
+#include "IStream.h"
+
+class IEventQueue;
+
+class CMockStream : public IStream
+{
+public:
+	CMockStream(IEventQueue& eventQueue) : IStream(eventQueue) { }
+	MOCK_METHOD0(close, void());
+	MOCK_METHOD2(read, UInt32(void*, UInt32));
+	MOCK_METHOD2(write, void(const void*, UInt32));
+	MOCK_METHOD0(flush, void());
+	MOCK_METHOD0(shutdownInput, void());
+	MOCK_METHOD0(shutdownOutput, void());
+	MOCK_CONST_METHOD0(getEventTarget, void*());
+	MOCK_CONST_METHOD0(isReady, bool());
+	MOCK_CONST_METHOD0(getSize, UInt32());
+};

src/test/unittests/synergy/CClipboardTests.cpp

@@ -0,0 +1,402 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ * 
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <gtest/gtest.h>
+#include "CClipboard.h"
+
+TEST(CClipboardTests, empty_openCalled_returnsTrue)
+{
+	CClipboard clipboard;
+	clipboard.open(0);
+
+	bool actual = clipboard.empty();
+
+	EXPECT_EQ(true, actual);
+}
+
+TEST(CClipboardTests, empty_singleFormat_hasReturnsFalse)
+{
+	CClipboard clipboard;
+	clipboard.open(0);
+	clipboard.add(CClipboard::kText, "synergy rocks!");
+
+	clipboard.empty();
+
+	bool actual = clipboard.has(CClipboard::kText);
+	EXPECT_FALSE(actual);
+}
+
+TEST(CClipboardTests, add_newValue_valueWasStored)
+{
+	CClipboard clipboard;
+	clipboard.open(0);
+
+	clipboard.add(IClipboard::kText, "synergy rocks!");
+
+	CString actual = clipboard.get(IClipboard::kText);
+	EXPECT_EQ("synergy rocks!", actual);
+}
+
+TEST(CClipboardTests, add_replaceValue_valueWasReplaced)
+{
+	CClipboard 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);
+	EXPECT_EQ("maxivista sucks", actual);
+}
+
+TEST(CClipboardTests, open_timeIsZero_returnsTrue)
+{
+	CClipboard clipboard;
+
+	bool actual = clipboard.open(0);
+
+	EXPECT_EQ(true, actual);
+}
+
+TEST(CClipboardTests, open_timeIsOne_returnsTrue)
+{
+	CClipboard clipboard;
+
+	bool actual = clipboard.open(1);
+
+	EXPECT_EQ(true, actual);
+}
+
+TEST(CClipboardTests, close_isOpen_noErrors)
+{
+	CClipboard clipboard;
+	clipboard.open(0);
+
+	clipboard.close();
+
+	// can't assert anything
+}
+
+TEST(CClipboardTests, getTime_openWithNoEmpty_returnsZero)
+{
+	CClipboard clipboard;
+	clipboard.open(1);
+
+	CClipboard::Time actual = clipboard.getTime();
+
+	EXPECT_EQ(0, actual);
+}
+
+TEST(CClipboardTests, getTime_openAndEmpty_returnsOne)
+{
+	CClipboard clipboard;
+	clipboard.open(1);
+	clipboard.empty();
+
+	CClipboard::Time actual = clipboard.getTime();
+
+	EXPECT_EQ(1, actual);
+}
+
+TEST(CClipboardTests, has_withFormatAdded_returnsTrue)
+{
+	CClipboard clipboard;
+	clipboard.open(0);
+	clipboard.add(IClipboard::kText, "synergy rocks!");
+
+	bool actual = clipboard.has(IClipboard::kText);
+
+	EXPECT_EQ(true, actual);
+}
+
+TEST(CClipboardTests, has_withNoFormats_returnsFalse)
+{
+	CClipboard clipboard;
+	clipboard.open(0);
+
+	bool actual = clipboard.has(IClipboard::kText);
+
+	EXPECT_FALSE(actual);
+}
+
+TEST(CClipboardTests, get_withNoFormats_returnsEmpty)
+{
+	CClipboard clipboard;
+	clipboard.open(0);
+
+	CString actual = clipboard.get(IClipboard::kText);
+
+	EXPECT_EQ("", actual);
+}
+
+TEST(CClipboardTests, get_withFormatAdded_returnsExpected)
+{
+	CClipboard clipboard;
+	clipboard.open(0);
+	clipboard.add(IClipboard::kText, "synergy rocks!");
+
+	CString actual = clipboard.get(IClipboard::kText);
+
+	EXPECT_EQ("synergy rocks!", actual);
+}
+
+TEST(CClipboardTests, marshall_addNotCalled_firstCharIsZero)
+{
+	CClipboard clipboard;
+
+	CString 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)
+{
+	CClipboard clipboard;
+	clipboard.open(0);
+	clipboard.add(IClipboard::kText, "synergy rocks!");
+	clipboard.close();
+
+	CString 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)
+{
+	CClipboard clipboard;
+	clipboard.open(0);
+	clipboard.add(IClipboard::kText, "synergy rocks!"); // 14 chars
+	clipboard.close();
+
+	CString actual = clipboard.marshall();
+
+	EXPECT_EQ(14, (int)actual[11]);
+}
+
+// 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)
+{
+	// 285 chars
+	CString 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.open(0);
+	clipboard.add(IClipboard::kText, data);
+	clipboard.close();
+
+	CString 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
+	// (29 more than the 8-bit max size), the last char "rolls over" to 29 
+	// (this is caused by a bit-wise & on 0xff and 8-bit truncation). each 
+	// char before the last stores a bit-shifted version of the number, each 
+	// 1 more power than the last, which is done by bit-shifting [0] by 24, 
+	// [1] by 16, [2] by 8 ([3] is not bit-shifted).
+	EXPECT_EQ(0, actual[8]); // 285 >> 24 = 285 / (256^3) = 0
+	EXPECT_EQ(0, actual[9]); // 285 >> 16 = 285 / (256^2) = 0
+	EXPECT_EQ(1, actual[10]); // 285 >> 8 = 285 / (256^1) = 1(.11328125)
+	EXPECT_EQ(29, actual[11]); // 285 - 256 = 29
+}
+
+TEST(CClipboardTests, marshall_withHtmlAdded_typeCharIsHtml)
+{
+	CClipboard clipboard;
+	clipboard.open(0);
+	clipboard.add(IClipboard::kHTML, "html sucks");
+	clipboard.close();
+
+	CString 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)
+{
+	CClipboard clipboard;
+	clipboard.open(0);
+	clipboard.add(IClipboard::kText, "synergy rocks");
+	clipboard.add(IClipboard::kHTML, "html sucks");
+	clipboard.close();
+
+	CString actual = clipboard.marshall();
+
+	// the number of formats is stored inside the first 4 chars.
+	// the writeUInt32 function right-aligns numbers in 4 chars,
+	// so if you right align 2, it will be "\0\0\0\2" in a string.
+	// we assert that the char at the 4th index is 2 (the number of
+	// formats that we've added).
+	EXPECT_EQ(2, (int)actual[3]);
+}
+
+TEST(CClipboardTests, marshall_withTextAdded_endsWithAdded)
+{
+	CClipboard clipboard;
+	clipboard.open(0);
+	clipboard.add(IClipboard::kText, "synergy rocks!");
+	clipboard.close();
+
+	CString 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)
+{
+	CClipboard clipboard;
+
+	CString data;
+	data += (char)0;
+	data += (char)0;
+	data += (char)0;
+	data += (char)0; // 0 formats added
+
+	clipboard.unmarshall(data, 0);
+
+	clipboard.open(0);
+	bool actual = clipboard.has(IClipboard::kText);
+	EXPECT_FALSE(actual);
+}
+
+TEST(CClipboardTests, unmarshall_withTextSize285_getTextIsValid)
+{
+	CClipboard clipboard;
+
+	// 285 chars
+	CString 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;
+	data += (char)0;
+	data += (char)0;
+	data += (char)0;
+	data += (char)1; // 1 format added
+	data += (char)0;
+	data += (char)0;
+	data += (char)0;
+	data += (char)IClipboard::kText;
+	data += (char)0; // 285 >> 24 = 285 / (256^3) = 0
+	data += (char)0; // 285 >> 16 = 285 / (256^2) = 0
+	data += (char)1; // 285 >> 8 = 285 / (256^1) = 1(.11328125)
+	data += (char)29; // 285 - 256 = 29
+	data += text;
+
+	clipboard.unmarshall(data, 0);
+
+	clipboard.open(0);
+	CString actual = clipboard.get(IClipboard::kText);
+	EXPECT_EQ(text, actual);
+}
+
+TEST(CClipboardTests, unmarshall_withTextAndHtml_getTextIsValid)
+{
+	CClipboard clipboard;
+	CString data;
+	data += (char)0;
+	data += (char)0;
+	data += (char)0;
+	data += (char)2; // 2 formats added
+	data += (char)0;
+	data += (char)0;
+	data += (char)0;
+	data += (char)IClipboard::kText;
+	data += (char)0;
+	data += (char)0;
+	data += (char)0;
+	data += (char)14;
+	data += "synergy rocks!";
+	data += (char)0;
+	data += (char)0;
+	data += (char)0;
+	data += (char)IClipboard::kHTML;
+	data += (char)0;
+	data += (char)0;
+	data += (char)0;
+	data += (char)10;
+	data += "html sucks";
+
+	clipboard.unmarshall(data, 0);
+
+	clipboard.open(0);
+	CString actual = clipboard.get(IClipboard::kText);
+	EXPECT_EQ("synergy rocks!", actual);
+}
+
+TEST(CClipboardTests, unmarshall_withTextAndHtml_getHtmlIsValid)
+{
+	CClipboard clipboard;
+	CString data;
+	data += (char)0;
+	data += (char)0;
+	data += (char)0;
+	data += (char)2; // 2 formats added
+	data += (char)0;
+	data += (char)0;
+	data += (char)0;
+	data += (char)IClipboard::kText;
+	data += (char)0;
+	data += (char)0;
+	data += (char)0;
+	data += (char)14;
+	data += "synergy rocks!";
+	data += (char)0;
+	data += (char)0;
+	data += (char)0;
+	data += (char)IClipboard::kHTML;
+	data += (char)0;
+	data += (char)0;
+	data += (char)0;
+	data += (char)10;
+	data += "html sucks";
+
+	clipboard.unmarshall(data, 0);
+
+	clipboard.open(0);
+	CString actual = clipboard.get(IClipboard::kHTML);
+	EXPECT_EQ("html sucks", actual);
+}
+
+TEST(CClipboardTests, copy_withSingleText_clipboardsAreEqual)
+{
+	CClipboard clipboard1;
+	clipboard1.open(0);
+	clipboard1.add(CClipboard::kText, "synergy rocks!");
+	clipboard1.close();
+
+	CClipboard clipboard2;
+	CClipboard::copy(&clipboard2, &clipboard1);
+
+	clipboard2.open(0);
+	CString actual = clipboard2.get(CClipboard::kText);
+	EXPECT_EQ("synergy rocks!", actual);
+}

src/test/unittests/synergy/CKeyStateTests.cpp

@@ -0,0 +1,451 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ * 
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "CKeyStateTests.h"
+#include "CMockEventQueue.h"
+#include "CMockKeyMap.h"
+
+using ::testing::_;
+using ::testing::NiceMock;
+using ::testing::Invoke;
+using ::testing::Return;
+using ::testing::SaveArg;
+
+TEST(CKeyStateTests, onKey_aKeyDown_keyStateOne)
+{
+	CMockKeyMap keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	keyState.onKey(1, true, KeyModifierAlt);
+
+	EXPECT_EQ(1, keyState.getKeyState(1));
+}
+
+TEST(CKeyStateTests, onKey_aKeyUp_keyStateZero)
+{
+	CMockKeyMap keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	keyState.onKey(1, false, KeyModifierAlt);
+
+	EXPECT_EQ(0, keyState.getKeyState(1));
+}
+
+TEST(CKeyStateTests, onKey_invalidKey_keyStateZero)
+{
+	CMockKeyMap keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	keyState.onKey(0, true, KeyModifierAlt);
+
+	EXPECT_EQ(0, keyState.getKeyState(0));
+}
+
+TEST(CKeyStateTests, sendKeyEvent_halfDuplexAndRepeat_addEventNotCalled)
+{
+	NiceMock<CMockKeyMap> keyMap;
+	NiceMock<CMockEventQueue> eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+	ON_CALL(keyMap, isHalfDuplex(_, _)).WillByDefault(Return(true));
+
+	EXPECT_CALL(eventQueue, addEvent(_)).Times(0);
+
+	keyState.sendKeyEvent(NULL, false, true, kKeyCapsLock, 0, 0, 0);
+}
+
+TEST(CKeyStateTests, sendKeyEvent_halfDuplex_addEventCalledTwice)
+{
+	NiceMock<CMockKeyMap> keyMap;
+	NiceMock<CMockEventQueue> eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+	ON_CALL(keyMap, isHalfDuplex(_, _)).WillByDefault(Return(true));
+
+	EXPECT_CALL(eventQueue, addEvent(_)).Times(2);
+
+	keyState.sendKeyEvent(NULL, false, false, kKeyCapsLock, 0, 0, 0);
+}
+
+TEST(CKeyStateTests, sendKeyEvent_keyRepeat_addEventCalledOnce)
+{
+	NiceMock<CMockKeyMap> keyMap;
+	NiceMock<CMockEventQueue> eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	EXPECT_CALL(eventQueue, addEvent(_)).Times(1);
+
+	keyState.sendKeyEvent(NULL, false, true, 1, 0, 0, 0);
+}
+
+TEST(CKeyStateTests, sendKeyEvent_keyDown_addEventCalledOnce)
+{
+	NiceMock<CMockKeyMap> keyMap;
+	NiceMock<CMockEventQueue> eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	EXPECT_CALL(eventQueue, addEvent(_)).Times(1);
+
+	keyState.sendKeyEvent(NULL, true, false, 1, 0, 0, 0);
+}
+
+TEST(CKeyStateTests, sendKeyEvent_keyUp_addEventCalledOnce)
+{
+	NiceMock<CMockKeyMap> keyMap;
+	NiceMock<CMockEventQueue> eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	EXPECT_CALL(eventQueue, addEvent(_)).Times(1);
+
+	keyState.sendKeyEvent(NULL, false, false, 1, 0, 0, 0);
+}
+
+TEST(CKeyStateTests, updateKeyMap_mockKeyMap_keyMapGotMock)
+{
+	NiceMock<CMockKeyMap> keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	// key map member gets a new key map via swap()
+	EXPECT_CALL(keyMap, swap(_));
+
+	keyState.updateKeyMap();
+}
+
+TEST(CKeyStateTests, updateKeyState_pollInsertsSingleKey_keyIsDown)
+{
+	NiceMock<CMockKeyMap> keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+	ON_CALL(keyState, pollPressedKeys(_)).WillByDefault(Invoke(stubPollPressedKeys));
+
+	keyState.updateKeyState();
+
+	bool actual = keyState.isKeyDown(1);
+	ASSERT_TRUE(actual);
+}
+
+TEST(CKeyStateTests, updateKeyState_pollDoesNothing_keyNotSet)
+{
+	NiceMock<CMockKeyMap> keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	keyState.updateKeyState();
+
+	bool actual = keyState.isKeyDown(1);
+	ASSERT_FALSE(actual);
+}
+
+TEST(CKeyStateTests, updateKeyState_activeModifiers_maskSet)
+{
+	NiceMock<CMockKeyMap> keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+	ON_CALL(keyState, pollActiveModifiers()).WillByDefault(Return(KeyModifierAlt));
+
+	keyState.updateKeyState();
+
+	KeyModifierMask actual = keyState.getActiveModifiers();
+	ASSERT_EQ(KeyModifierAlt, actual);
+}
+
+TEST(CKeyStateTests, updateKeyState_activeModifiers_maskNotSet)
+{
+	NiceMock<CMockKeyMap> keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	keyState.updateKeyState();
+
+	KeyModifierMask actual = keyState.getActiveModifiers();
+	ASSERT_EQ(0, actual);
+}
+
+TEST(CKeyStateTests, updateKeyState_activeModifiers_keyMapGotModifers)
+{
+	CMockKeyMap keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+	ON_CALL(keyState, pollActiveModifiers()).WillByDefault(Return(1));
+	ON_CALL(keyMap, foreachKey(_, _)).WillByDefault(Invoke(assertMaskIsOne));
+
+	// key map gets new modifiers via foreachKey()
+	EXPECT_CALL(keyMap, foreachKey(_, _));
+
+	keyState.updateKeyState();
+}
+
+TEST(CKeyStateTests, setHalfDuplexMask_capsLock_halfDuplexCapsLockAdded)
+{
+	CMockKeyMap keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	EXPECT_CALL(keyMap, addHalfDuplexModifier(kKeyCapsLock));
+
+	keyState.setHalfDuplexMask(KeyModifierCapsLock);
+}
+
+TEST(CKeyStateTests, setHalfDuplexMask_numLock_halfDuplexNumLockAdded)
+{
+	CMockKeyMap keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	EXPECT_CALL(keyMap, addHalfDuplexModifier(kKeyNumLock));
+
+	keyState.setHalfDuplexMask(KeyModifierNumLock);
+}
+
+TEST(CKeyStateTests, setHalfDuplexMask_scrollLock_halfDuplexScollLockAdded)
+{
+	CMockKeyMap keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	EXPECT_CALL(keyMap, addHalfDuplexModifier(kKeyScrollLock));
+
+	keyState.setHalfDuplexMask(KeyModifierScrollLock);
+}
+
+TEST(CKeyStateTests, fakeKeyDown_serverKeyAlreadyDown_fakeKeyCalledTwice)
+{
+	NiceMock<CMockKeyMap> keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+	s_stubKeyItem.m_client = 0;
+	s_stubKeyItem.m_button = 1;
+	ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Invoke(stubMapKey));
+
+	// 2 calls to fakeKeyDown should still call fakeKey, even though
+	// repeated keys are handled differently.
+	EXPECT_CALL(keyState, fakeKey(_)).Times(2);
+
+	// call twice to simulate server key already down (a misreported autorepeat).
+	keyState.fakeKeyDown(1, 0, 0);
+	keyState.fakeKeyDown(1, 0, 0);
+}
+
+TEST(CKeyStateTests, fakeKeyDown_isIgnoredKey_fakeKeyNotCalled)
+{
+	CMockKeyMap keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	EXPECT_CALL(keyState, fakeKey(_)).Times(0);
+
+	keyState.fakeKeyDown(kKeyCapsLock, 0, 0);
+}
+
+TEST(CKeyStateTests, fakeKeyDown_mapReturnsKeystrokes_fakeKeyCalled)
+{
+	NiceMock<CMockKeyMap> keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+	s_stubKeyItem.m_button = 0;
+	s_stubKeyItem.m_client = 0;
+	ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Invoke(stubMapKey));
+
+	EXPECT_CALL(keyState, fakeKey(_)).Times(1);
+
+	keyState.fakeKeyDown(1, 0, 0);
+}
+
+TEST(CKeyStateTests, fakeKeyRepeat_invalidKey_returnsFalse)
+{
+	CMockKeyMap keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	bool actual = keyState.fakeKeyRepeat(0, 0, 0, 0);
+
+	ASSERT_FALSE(actual);
+}
+
+TEST(CKeyStateTests, fakeKeyRepeat_nullKey_returnsFalse)
+{
+	NiceMock<CMockKeyMap> keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	// set the key to down (we need to make mapKey return a valid key to do this).
+	CKeyMap::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;
+	ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Return(nullKeyItem));
+
+	bool actual = keyState.fakeKeyRepeat(1, 0, 0, 0);
+
+	ASSERT_FALSE(actual);
+}
+
+TEST(CKeyStateTests, fakeKeyRepeat_invalidButton_returnsFalse)
+{
+	NiceMock<CMockKeyMap> keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	// set the key to down (we need to make mapKey return a valid key to do this).
+	CKeyMap::KeyItem keyItem;
+	keyItem.m_client = 0;
+	keyItem.m_button = 1; // set to 1 to make fakeKeyDown work.
+	ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Return(&keyItem));
+	keyState.fakeKeyDown(1, 0, 0);
+
+	// change button to 0 so that fakeKeyRepeat will return early.
+	keyItem.m_button = 0;
+	ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Return(&keyItem));
+
+	bool actual = keyState.fakeKeyRepeat(1, 0, 0, 0);
+
+	ASSERT_FALSE(actual);
+}
+
+TEST(CKeyStateTests, fakeKeyRepeat_validKey_returnsTrue)
+{
+	NiceMock<CMockKeyMap> keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+	s_stubKeyItem.m_client = 0;
+	s_stubKeystroke.m_type = CKeyMap::Keystroke::kButton;
+	s_stubKeystroke.m_data.m_button.m_button = 2;
+
+	// set the button to 1 for fakeKeyDown call
+	s_stubKeyItem.m_button = 1;
+	ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Invoke(stubMapKey));
+	keyState.fakeKeyDown(1, 0, 0);
+
+	// change the button to 2
+	s_stubKeyItem.m_button = 2;
+	ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Invoke(stubMapKey));
+
+	bool actual = keyState.fakeKeyRepeat(1, 0, 0, 0);
+
+	ASSERT_TRUE(actual);
+}
+
+TEST(CKeyStateTests, fakeKeyUp_buttonNotDown_returnsFalse)
+{
+	CMockKeyMap keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	bool actual = keyState.fakeKeyUp(0);
+
+	ASSERT_FALSE(actual);
+}
+
+TEST(CKeyStateTests, fakeKeyUp_buttonAlreadyDown_returnsTrue)
+{
+	NiceMock<CMockKeyMap> keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	// press alt down so we get full coverage.
+	ON_CALL(keyState, pollActiveModifiers()).WillByDefault(Return(KeyModifierAlt));
+	keyState.updateKeyState();
+
+	// press button 1 down.
+	s_stubKeyItem.m_button = 1;
+	ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Invoke(stubMapKey));
+	keyState.fakeKeyDown(1, 0, 1);
+
+	// this takes the button id, which is the 3rd arg of fakeKeyDown
+	bool actual = keyState.fakeKeyUp(1);
+
+	ASSERT_TRUE(actual);
+}
+
+TEST(CKeyStateTests, fakeAllKeysUp_keysWereDown_keysAreUp)
+{
+	NiceMock<CMockKeyMap> keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	// press button 1 down.
+	s_stubKeyItem.m_button = 1;
+	ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Invoke(stubMapKey));
+	keyState.fakeKeyDown(1, 0, 1);
+
+	// method under test
+	keyState.fakeAllKeysUp();
+
+	bool actual = keyState.isKeyDown(1);
+	ASSERT_FALSE(actual);
+}
+
+TEST(CKeyStateTests, isKeyDown_keyDown_returnsTrue)
+{
+	NiceMock<CMockKeyMap> keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	// press button 1 down.
+	s_stubKeyItem.m_button = 1;
+	ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Invoke(stubMapKey));
+	keyState.fakeKeyDown(1, 0, 1);
+
+	// method under test
+	bool actual = keyState.isKeyDown(1);
+
+	ASSERT_TRUE(actual);
+}
+
+TEST(CKeyStateTests, isKeyDown_noKeysDown_returnsFalse)
+{
+	CMockKeyMap keyMap;
+	CMockEventQueue eventQueue;
+	CKeyStateImpl keyState(eventQueue, keyMap);
+
+	// method under test
+	bool actual = keyState.isKeyDown(1);
+
+	ASSERT_FALSE(actual);
+}
+
+void
+stubPollPressedKeys(IKeyState::KeyButtonSet& pressedKeys)
+{
+	pressedKeys.insert(1);
+}
+
+void
+assertMaskIsOne(ForeachKeyCallback cb, void* userData)
+{
+	ASSERT_EQ(1, ((CKeyState::CAddActiveModifierContext*)userData)->m_mask);
+}
+
+const CKeyMap::KeyItem*
+stubMapKey(
+	CKeyMap::Keystrokes& keys, KeyID id, SInt32 group,
+	CKeyMap::ModifierToKeys& activeModifiers,
+	KeyModifierMask& currentState,
+	KeyModifierMask desiredMask,
+	bool isAutoRepeat)
+{
+	keys.push_back(s_stubKeystroke);
+	return &s_stubKeyItem;
+}

src/test/unittests/synergy/CKeyStateTests.h

@@ -0,0 +1,73 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ * 
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CKEYSTATETESTS_H
+#define CKEYSTATETESTS_H
+
+#include "CKeyState.h"
+#include "gmock/gmock.h"
+
+class CMockKeyMap;
+class CMockEventQueue;
+
+// 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
+{
+public:
+	CMockKeyState() : CKeyState()
+	{
+	}
+
+	CMockKeyState(const CMockEventQueue& eventQueue, const CMockKeyMap& keyMap) :
+		CKeyState((IEventQueue&)eventQueue, (CKeyMap&)keyMap)
+	{
+	}
+
+	MOCK_CONST_METHOD0(pollActiveGroup, SInt32());
+	MOCK_CONST_METHOD0(pollActiveModifiers, KeyModifierMask());
+	MOCK_METHOD0(fakeCtrlAltDel, bool());
+	MOCK_METHOD1(getKeyMap, void(CKeyMap&));
+	MOCK_METHOD1(fakeKey, void(const Keystroke&));
+	MOCK_CONST_METHOD1(pollPressedKeys, void(KeyButtonSet&));
+};
+
+typedef ::testing::NiceMock<CMockKeyState> CKeyStateImpl;
+
+typedef UInt32 KeyID;
+
+typedef void (*ForeachKeyCallback)(
+		KeyID, SInt32 group, CKeyMap::KeyItem&, void* userData);
+
+void
+stubPollPressedKeys(IKeyState::KeyButtonSet& pressedKeys);
+
+void
+assertMaskIsOne(ForeachKeyCallback cb, void* userData);
+
+const CKeyMap::KeyItem*
+stubMapKey(
+	CKeyMap::Keystrokes& keys, KeyID id, SInt32 group,
+	CKeyMap::ModifierToKeys& activeModifiers,
+	KeyModifierMask& currentState,
+	KeyModifierMask desiredMask,
+	bool isAutoRepeat);
+
+CKeyMap::Keystroke s_stubKeystroke(1, false, false);
+CKeyMap::KeyItem s_stubKeyItem;
+
+#endif

src/test/unittests/synergy/CMockEventQueue.h

@@ -0,0 +1,45 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ * 
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMOCKEVENTQUEUE_H 
+#define CMOCKEVENTQUEUE_H
+
+#include <gmock/gmock.h>
+#include "IEventQueue.h"
+
+class CMockEventQueue : public IEventQueue
+{
+public:
+	MOCK_METHOD2(newOneShotTimer, CEventQueueTimer*(double, void*));
+	MOCK_METHOD2(newTimer, CEventQueueTimer*(double, void*));
+	MOCK_METHOD2(getEvent, bool(CEvent&, double));
+	MOCK_METHOD1(adoptBuffer, void(IEventQueueBuffer*));
+	MOCK_METHOD2(registerTypeOnce, CEvent::Type(CEvent::Type&, const char*));
+	MOCK_METHOD1(removeHandlers, void(void*));
+	MOCK_METHOD1(registerType, CEvent::Type(const char*));
+	MOCK_CONST_METHOD0(isEmpty, bool());
+	MOCK_METHOD3(adoptHandler, void(CEvent::Type, void*, IEventJob*));
+	MOCK_METHOD1(getTypeName, const char*(CEvent::Type));
+	MOCK_METHOD1(addEvent, void(const CEvent&));
+	MOCK_METHOD2(removeHandler, void(CEvent::Type, void*));
+	MOCK_METHOD1(dispatchEvent, bool(const CEvent&));
+	MOCK_CONST_METHOD2(getHandler, IEventJob*(CEvent::Type, void*));
+	MOCK_METHOD1(deleteTimer, void(CEventQueueTimer*));
+	MOCK_CONST_METHOD1(getRegisteredType, CEvent::Type(const CString&));
+};
+
+#endif

src/test/unittests/synergy/CMockKeyMap.h

@@ -0,0 +1,37 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
+ *
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ *
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef CMOCKKEYMAP_H
+#define CMOCKKEYMAP_H
+
+#include <gmock/gmock.h>
+#include "CKeyMap.h"
+
+class CMockKeyMap : public CKeyMap
+{
+public:
+	MOCK_METHOD1(swap, void(CKeyMap&));
+	MOCK_METHOD0(finish, void());
+	MOCK_METHOD2(foreachKey, void(ForeachKeyCallback, void*));
+	MOCK_METHOD1(addHalfDuplexModifier, void(KeyID));
+	MOCK_CONST_METHOD2(isHalfDuplex, bool(KeyID, KeyButton));
+	MOCK_CONST_METHOD7(mapKey, const CKeyMap::KeyItem*(
+		Keystrokes&, KeyID, SInt32, ModifierToKeys&, KeyModifierMask&,
+		KeyModifierMask, bool));
+};
+
+#endif