dropped "c" prefix from class names

src/test/global/TestEventQueue.cpp

@@ -23,31 +23,31 @@
 #include "common/stdexcept.h"
 
 void
-CTestEventQueue::raiseQuitEvent() 
+TestEventQueue::raiseQuitEvent() 
 {
-	addEvent(CEvent(CEvent::kQuit));
+	addEvent(Event(Event::kQuit));
 }
 
 void
-CTestEventQueue::initQuitTimeout(double timeout)
+TestEventQueue::initQuitTimeout(double timeout)
 {
 	assert(m_quitTimeoutTimer == nullptr);
 	m_quitTimeoutTimer = newOneShotTimer(timeout, NULL);
-	adoptHandler(CEvent::kTimer, m_quitTimeoutTimer,
-		new TMethodEventJob<CTestEventQueue>(
-		this, &CTestEventQueue::handleQuitTimeout));
+	adoptHandler(Event::kTimer, m_quitTimeoutTimer,
+		new TMethodEventJob<TestEventQueue>(
+		this, &TestEventQueue::handleQuitTimeout));
 }
 
 void
-CTestEventQueue::cleanupQuitTimeout()
+TestEventQueue::cleanupQuitTimeout()
 {
-	removeHandler(CEvent::kTimer, m_quitTimeoutTimer);
+	removeHandler(Event::kTimer, m_quitTimeoutTimer);
 	delete m_quitTimeoutTimer;
 	m_quitTimeoutTimer = nullptr;
 }
 
 void
-CTestEventQueue::handleQuitTimeout(const CEvent&, void* vclient)
+TestEventQueue::handleQuitTimeout(const Event&, void* vclient)
 {
 	throw std::runtime_error("test event queue timeout");
 }

src/test/global/TestEventQueue.h

@@ -19,13 +19,13 @@
 
 #include "base/EventQueue.h"
 
-class CEventQueueTimer;
+class EventQueueTimer;
 
-class CTestEventQueue : public CEventQueue {
+class TestEventQueue : public EventQueue {
 public:
-	CTestEventQueue() : m_quitTimeoutTimer(nullptr) { }
+	TestEventQueue() : m_quitTimeoutTimer(nullptr) { }
 
-	void				handleQuitTimeout(const CEvent&, void* vclient);
+	void				handleQuitTimeout(const Event&, void* vclient);
 	void				raiseQuitEvent();
 	void				initQuitTimeout(double timeout);
 	void				cleanupQuitTimeout();
@@ -34,5 +34,5 @@ private:
 	void				timeoutThread(void*);
 
 private:
-	CEventQueueTimer*	m_quitTimeoutTimer;
+	EventQueueTimer*	m_quitTimeoutTimer;
 };

src/test/integtests/Main.cpp

@@ -39,13 +39,13 @@ main(int argc, char **argv)
 {
 #if SYSAPI_WIN32
 	// record window instance for tray icon, etc
-	CArchMiscWindows::setInstanceWin32(GetModuleHandle(NULL));
+	ArchMiscWindows::setInstanceWin32(GetModuleHandle(NULL));
 #endif
 
-	CArch arch;
+	Arch arch;
 	arch.init();
 	
-	CLog log;
+	Log log;
 	log.setFilter(kDEBUG2);
 
 	string lockFile;

src/test/integtests/arch/ArchInternetTests.cpp

@@ -25,13 +25,13 @@
 TEST(ArchInternetTests, get)
 {
 	ARCH_INTERNET internet;
-	CString result = internet.get(TEST_URL);
+	String result = internet.get(TEST_URL);
 	ASSERT_EQ("Hello world!", result);
 }
 
 TEST(ArchInternetTests, urlEncode)
 {
 	ARCH_INTERNET internet;
-	CString result = internet.urlEncode("hello=+&world");
+	String result = internet.urlEncode("hello=+&world");
 	ASSERT_EQ("hello%3D%2B%26world", result);
 }

src/test/integtests/ipc/IpcTests.cpp

@@ -41,109 +41,109 @@
 
 #define TEST_IPC_PORT 24802
 
-class CIpcTests : public ::testing::Test
+class IpcTests : public ::testing::Test
 {
 public:
-	CIpcTests();
-	virtual ~CIpcTests();
+	IpcTests();
+	virtual ~IpcTests();
 	
-	void				connectToServer_handleMessageReceived(const CEvent&, void*);
-	void				sendMessageToServer_serverHandleMessageReceived(const CEvent&, void*);
-	void				sendMessageToClient_serverHandleClientConnected(const CEvent&, void*);
-	void				sendMessageToClient_clientHandleMessageReceived(const CEvent&, void*);
+	void				connectToServer_handleMessageReceived(const Event&, void*);
+	void				sendMessageToServer_serverHandleMessageReceived(const Event&, void*);
+	void				sendMessageToClient_serverHandleClientConnected(const Event&, void*);
+	void				sendMessageToClient_clientHandleMessageReceived(const Event&, void*);
 
 public:
-	CSocketMultiplexer	m_multiplexer;
+	SocketMultiplexer	m_multiplexer;
 	bool				m_connectToServer_helloMessageReceived;
 	bool				m_connectToServer_hasClientNode;
-	CIpcServer*			m_connectToServer_server;
-	CString				m_sendMessageToServer_receivedString;
-	CString				m_sendMessageToClient_receivedString;
-	CIpcClient*			m_sendMessageToServer_client;
-	CIpcServer*			m_sendMessageToClient_server;
-	CTestEventQueue		m_events;
+	IpcServer*			m_connectToServer_server;
+	String				m_sendMessageToServer_receivedString;
+	String				m_sendMessageToClient_receivedString;
+	IpcClient*			m_sendMessageToServer_client;
+	IpcServer*			m_sendMessageToClient_server;
+	TestEventQueue		m_events;
 
 };
 
-TEST_F(CIpcTests, connectToServer)
+TEST_F(IpcTests, connectToServer)
 {
-	CSocketMultiplexer socketMultiplexer;
-	CIpcServer server(&m_events, &socketMultiplexer, TEST_IPC_PORT);
+	SocketMultiplexer socketMultiplexer;
+	IpcServer server(&m_events, &socketMultiplexer, TEST_IPC_PORT);
 	server.listen();
 	m_connectToServer_server = &server;
 
 	m_events.adoptHandler(
-		m_events.forCIpcServer().messageReceived(), &server,
-		new TMethodEventJob<CIpcTests>(
-		this, &CIpcTests::connectToServer_handleMessageReceived));
+		m_events.forIpcServer().messageReceived(), &server,
+		new TMethodEventJob<IpcTests>(
+		this, &IpcTests::connectToServer_handleMessageReceived));
 	
-	CIpcClient client(&m_events, &socketMultiplexer, TEST_IPC_PORT);
+	IpcClient client(&m_events, &socketMultiplexer, TEST_IPC_PORT);
 	client.connect();
 	
 	m_events.initQuitTimeout(5);
 	m_events.loop();
-	m_events.removeHandler(m_events.forCIpcServer().messageReceived(), &server);
+	m_events.removeHandler(m_events.forIpcServer().messageReceived(), &server);
 	m_events.cleanupQuitTimeout();
 	
 	EXPECT_EQ(true, m_connectToServer_helloMessageReceived);
 	EXPECT_EQ(true, m_connectToServer_hasClientNode);
 }
 
-TEST_F(CIpcTests, sendMessageToServer)
+TEST_F(IpcTests, sendMessageToServer)
 {
-	CSocketMultiplexer socketMultiplexer;
-	CIpcServer server(&m_events, &socketMultiplexer, TEST_IPC_PORT);
+	SocketMultiplexer socketMultiplexer;
+	IpcServer server(&m_events, &socketMultiplexer, TEST_IPC_PORT);
 	server.listen();
 	
 	// event handler sends "test" command to server.
 	m_events.adoptHandler(
-		m_events.forCIpcServer().messageReceived(), &server,
-		new TMethodEventJob<CIpcTests>(
-		this, &CIpcTests::sendMessageToServer_serverHandleMessageReceived));
+		m_events.forIpcServer().messageReceived(), &server,
+		new TMethodEventJob<IpcTests>(
+		this, &IpcTests::sendMessageToServer_serverHandleMessageReceived));
 	
-	CIpcClient client(&m_events, &socketMultiplexer, TEST_IPC_PORT);
+	IpcClient client(&m_events, &socketMultiplexer, TEST_IPC_PORT);
 	client.connect();
 	m_sendMessageToServer_client = &client;
 
 	m_events.initQuitTimeout(5);
 	m_events.loop();
-	m_events.removeHandler(m_events.forCIpcServer().messageReceived(), &server);
+	m_events.removeHandler(m_events.forIpcServer().messageReceived(), &server);
 	m_events.cleanupQuitTimeout();
 
 	EXPECT_EQ("test", m_sendMessageToServer_receivedString);
 }
 
-TEST_F(CIpcTests, sendMessageToClient)
+TEST_F(IpcTests, sendMessageToClient)
 {
-	CSocketMultiplexer socketMultiplexer;
-	CIpcServer server(&m_events, &socketMultiplexer, TEST_IPC_PORT);
+	SocketMultiplexer socketMultiplexer;
+	IpcServer server(&m_events, &socketMultiplexer, TEST_IPC_PORT);
 	server.listen();
 	m_sendMessageToClient_server = &server;
 
 	// event handler sends "test" log line to client.
 	m_events.adoptHandler(
-		m_events.forCIpcServer().messageReceived(), &server,
-		new TMethodEventJob<CIpcTests>(
-		this, &CIpcTests::sendMessageToClient_serverHandleClientConnected));
+		m_events.forIpcServer().messageReceived(), &server,
+		new TMethodEventJob<IpcTests>(
+		this, &IpcTests::sendMessageToClient_serverHandleClientConnected));
 
-	CIpcClient client(&m_events, &socketMultiplexer, TEST_IPC_PORT);
+	IpcClient client(&m_events, &socketMultiplexer, TEST_IPC_PORT);
 	client.connect();
 	
 	m_events.adoptHandler(
-		m_events.forCIpcClient().messageReceived(), &client,
-		new TMethodEventJob<CIpcTests>(
-		this, &CIpcTests::sendMessageToClient_clientHandleMessageReceived));
+		m_events.forIpcClient().messageReceived(), &client,
+		new TMethodEventJob<IpcTests>(
+		this, &IpcTests::sendMessageToClient_clientHandleMessageReceived));
 
 	m_events.initQuitTimeout(5);
 	m_events.loop();
-	m_events.removeHandler(m_events.forCIpcServer().messageReceived(), &server);
-	m_events.removeHandler(m_events.forCIpcClient().messageReceived(), &client);
+	m_events.removeHandler(m_events.forIpcServer().messageReceived(), &server);
+	m_events.removeHandler(m_events.forIpcClient().messageReceived(), &client);
 	m_events.cleanupQuitTimeout();
 
 	EXPECT_EQ("test", m_sendMessageToClient_receivedString);
 }
 
-CIpcTests::CIpcTests() :
+IpcTests::IpcTests() :
 m_connectToServer_helloMessageReceived(false),
 m_connectToServer_hasClientNode(false),
 m_connectToServer_server(nullptr),
@@ -152,14 +152,14 @@ m_sendMessageToServer_client(nullptr)
 {
 }
 
-CIpcTests::~CIpcTests()
+IpcTests::~IpcTests()
 {
 }
 
 void
-CIpcTests::connectToServer_handleMessageReceived(const CEvent& e, void*)
+IpcTests::connectToServer_handleMessageReceived(const Event& e, void*)
 {
-	CIpcMessage* m = static_cast<CIpcMessage*>(e.getDataObject());
+	IpcMessage* m = static_cast<IpcMessage*>(e.getDataObject());
 	if (m->type() == kIpcHello) {
 		m_connectToServer_hasClientNode =
 			m_connectToServer_server->hasClients(kIpcClientNode);
@@ -169,16 +169,16 @@ CIpcTests::connectToServer_handleMessageReceived(const CEvent& e, void*)
 }
 
 void
-CIpcTests::sendMessageToServer_serverHandleMessageReceived(const CEvent& e, void*)
+IpcTests::sendMessageToServer_serverHandleMessageReceived(const Event& e, void*)
 {
-	CIpcMessage* m = static_cast<CIpcMessage*>(e.getDataObject());
+	IpcMessage* m = static_cast<IpcMessage*>(e.getDataObject());
 	if (m->type() == kIpcHello) {
 		LOG((CLOG_DEBUG "client said hello, sending test to server"));
-		CIpcCommandMessage m("test", true);
+		IpcCommandMessage m("test", true);
 		m_sendMessageToServer_client->send(m);
 	}
 	else if (m->type() == kIpcCommand) {
-		CIpcCommandMessage* cm = static_cast<CIpcCommandMessage*>(m);
+		IpcCommandMessage* cm = static_cast<IpcCommandMessage*>(m);
 		LOG((CLOG_DEBUG "got ipc command message, %d", cm->command().c_str()));
 		m_sendMessageToServer_receivedString = cm->command();
 		m_events.raiseQuitEvent();
@@ -186,22 +186,22 @@ CIpcTests::sendMessageToServer_serverHandleMessageReceived(const CEvent& e, void
 }
 
 void
-CIpcTests::sendMessageToClient_serverHandleClientConnected(const CEvent& e, void*)
+IpcTests::sendMessageToClient_serverHandleClientConnected(const Event& e, void*)
 {
-	CIpcMessage* m = static_cast<CIpcMessage*>(e.getDataObject());
+	IpcMessage* m = static_cast<IpcMessage*>(e.getDataObject());
 	if (m->type() == kIpcHello) {
 		LOG((CLOG_DEBUG "client said hello, sending test to client"));
-		CIpcLogLineMessage m("test");
+		IpcLogLineMessage m("test");
 		m_sendMessageToClient_server->send(m, kIpcClientNode);
 	}
 }
 
 void
-CIpcTests::sendMessageToClient_clientHandleMessageReceived(const CEvent& e, void*)
+IpcTests::sendMessageToClient_clientHandleMessageReceived(const Event& e, void*)
 {
-	CIpcMessage* m = static_cast<CIpcMessage*>(e.getDataObject());
+	IpcMessage* m = static_cast<IpcMessage*>(e.getDataObject());
 	if (m->type() == kIpcLogLine) {
-		CIpcLogLineMessage* llm = static_cast<CIpcLogLineMessage*>(m);
+		IpcLogLineMessage* llm = static_cast<IpcLogLineMessage*>(m);
 		LOG((CLOG_DEBUG "got ipc log message, %d", llm->logLine().c_str()));
 		m_sendMessageToClient_receivedString = llm->logLine();
 		m_events.raiseQuitEvent();

src/test/integtests/net/NetworkTests.cpp

@@ -61,7 +61,7 @@ const size_t kMockFileSize = 1024 * 1024 * 10; // 10MB
 
 void getScreenShape(SInt32& x, SInt32& y, SInt32& w, SInt32& h);
 void getCursorPos(SInt32& x, SInt32& y);
-CString intToString(size_t i);
+String intToString(size_t i);
 UInt8* newMockData(size_t size);
 void createFile(fstream& file, const char* filename, size_t size);
 
@@ -85,20 +85,20 @@ public:
 
 	void				sendMockData(void* eventTarget);
 	
-	void				sendToClient_mockData_handleClientConnected(const CEvent&, void* vlistener);
-	void				sendToClient_mockData_fileRecieveCompleted(const CEvent&, void*);
+	void				sendToClient_mockData_handleClientConnected(const Event&, void* vlistener);
+	void				sendToClient_mockData_fileRecieveCompleted(const Event&, void*);
 	
-	void				sendToClient_mockFile_handleClientConnected(const CEvent&, void* vlistener);
-	void				sendToClient_mockFile_fileRecieveCompleted(const CEvent& event, void*);
+	void				sendToClient_mockFile_handleClientConnected(const Event&, void* vlistener);
+	void				sendToClient_mockFile_fileRecieveCompleted(const Event& event, void*);
 	
-	void				sendToServer_mockData_handleClientConnected(const CEvent&, void* vlistener);
-	void				sendToServer_mockData_fileRecieveCompleted(const CEvent& event, void*);
+	void				sendToServer_mockData_handleClientConnected(const Event&, void* vlistener);
+	void				sendToServer_mockData_fileRecieveCompleted(const Event& event, void*);
 
-	void				sendToServer_mockFile_handleClientConnected(const CEvent&, void* vlistener);
-	void				sendToServer_mockFile_fileRecieveCompleted(const CEvent& event, void*);
+	void				sendToServer_mockFile_handleClientConnected(const Event&, void* vlistener);
+	void				sendToServer_mockFile_fileRecieveCompleted(const Event& event, void*);
 	
 public:
-	CTestEventQueue		m_events;
+	TestEventQueue		m_events;
 	UInt8*				m_mockData;
 	size_t				m_mockDataSize;
 	fstream				m_mockFile;
@@ -108,41 +108,41 @@ public:
 TEST_F(NetworkTests, sendToClient_mockData)
 {
 	// server and client
-	CNetworkAddress serverAddress(TEST_HOST, TEST_PORT);
-	CCryptoOptions cryptoOptions;
+	NetworkAddress serverAddress(TEST_HOST, TEST_PORT);
+	CryptoOptions cryptoOptions;
 	
 	serverAddress.resolve();
 	
 	// server
-	CSocketMultiplexer serverSocketMultiplexer;
+	SocketMultiplexer serverSocketMultiplexer;
 	CTCPSocketFactory* serverSocketFactory = new CTCPSocketFactory(&m_events, &serverSocketMultiplexer);
-	CClientListener listener(serverAddress, serverSocketFactory, NULL, cryptoOptions, &m_events);
-	NiceMock<CMockScreen> serverScreen;
-	NiceMock<CMockPrimaryClient> primaryClient;
-	NiceMock<CMockConfig> serverConfig;
-	NiceMock<CMockInputFilter> serverInputFilter;
+	ClientListener listener(serverAddress, serverSocketFactory, NULL, cryptoOptions, &m_events);
+	NiceMock<MockScreen> serverScreen;
+	NiceMock<MockPrimaryClient> primaryClient;
+	NiceMock<MockConfig> serverConfig;
+	NiceMock<MockInputFilter> serverInputFilter;
 	
 	m_events.adoptHandler(
-		m_events.forCClientListener().connected(), &listener,
+		m_events.forClientListener().connected(), &listener,
 		new TMethodEventJob<NetworkTests>(
 			this, &NetworkTests::sendToClient_mockData_handleClientConnected, &listener));
 
 	ON_CALL(serverConfig, isScreen(_)).WillByDefault(Return(true));
 	ON_CALL(serverConfig, getInputFilter()).WillByDefault(Return(&serverInputFilter));
 	
-	CServer server(serverConfig, &primaryClient, &serverScreen, &m_events, true);
+	Server server(serverConfig, &primaryClient, &serverScreen, &m_events, true);
 	server.m_mock = true;
 	listener.setServer(&server);
 
 	// client
-	NiceMock<CMockScreen> clientScreen;
-	CSocketMultiplexer clientSocketMultiplexer;
+	NiceMock<MockScreen> clientScreen;
+	SocketMultiplexer clientSocketMultiplexer;
 	CTCPSocketFactory* clientSocketFactory = new CTCPSocketFactory(&m_events, &clientSocketMultiplexer);
 	
 	ON_CALL(clientScreen, getShape(_, _, _, _)).WillByDefault(Invoke(getScreenShape));
 	ON_CALL(clientScreen, getCursorPos(_, _)).WillByDefault(Invoke(getCursorPos));
 
-	CClient client(&m_events, "stub", serverAddress, clientSocketFactory, NULL, &clientScreen, cryptoOptions, true);
+	Client client(&m_events, "stub", serverAddress, clientSocketFactory, NULL, &clientScreen, cryptoOptions, true);
 		
 	m_events.adoptHandler(
 		m_events.forIScreen().fileRecieveCompleted(), &client,
@@ -153,7 +153,7 @@ TEST_F(NetworkTests, sendToClient_mockData)
 
 	m_events.initQuitTimeout(10);
 	m_events.loop();
-	m_events.removeHandler(m_events.forCClientListener().connected(), &listener);
+	m_events.removeHandler(m_events.forClientListener().connected(), &listener);
 	m_events.removeHandler(m_events.forIScreen().fileRecieveCompleted(), &client);
 	m_events.cleanupQuitTimeout();
 }
@@ -161,41 +161,41 @@ TEST_F(NetworkTests, sendToClient_mockData)
 TEST_F(NetworkTests, sendToClient_mockFile)
 {
 	// server and client
-	CNetworkAddress serverAddress(TEST_HOST, TEST_PORT);
-	CCryptoOptions cryptoOptions;
+	NetworkAddress serverAddress(TEST_HOST, TEST_PORT);
+	CryptoOptions cryptoOptions;
 	
 	serverAddress.resolve();
 	
 	// server
-	CSocketMultiplexer serverSocketMultiplexer;
+	SocketMultiplexer serverSocketMultiplexer;
 	CTCPSocketFactory* serverSocketFactory = new CTCPSocketFactory(&m_events, &serverSocketMultiplexer);
-	CClientListener listener(serverAddress, serverSocketFactory, NULL, cryptoOptions, &m_events);
-	NiceMock<CMockScreen> serverScreen;
-	NiceMock<CMockPrimaryClient> primaryClient;
-	NiceMock<CMockConfig> serverConfig;
-	NiceMock<CMockInputFilter> serverInputFilter;
+	ClientListener listener(serverAddress, serverSocketFactory, NULL, cryptoOptions, &m_events);
+	NiceMock<MockScreen> serverScreen;
+	NiceMock<MockPrimaryClient> primaryClient;
+	NiceMock<MockConfig> serverConfig;
+	NiceMock<MockInputFilter> serverInputFilter;
 	
 	m_events.adoptHandler(
-		m_events.forCClientListener().connected(), &listener,
+		m_events.forClientListener().connected(), &listener,
 		new TMethodEventJob<NetworkTests>(
 			this, &NetworkTests::sendToClient_mockFile_handleClientConnected, &listener));
 
 	ON_CALL(serverConfig, isScreen(_)).WillByDefault(Return(true));
 	ON_CALL(serverConfig, getInputFilter()).WillByDefault(Return(&serverInputFilter));
 	
-	CServer server(serverConfig, &primaryClient, &serverScreen, &m_events, true);
+	Server server(serverConfig, &primaryClient, &serverScreen, &m_events, true);
 	server.m_mock = true;
 	listener.setServer(&server);
 
 	// client
-	NiceMock<CMockScreen> clientScreen;
-	CSocketMultiplexer clientSocketMultiplexer;
+	NiceMock<MockScreen> clientScreen;
+	SocketMultiplexer clientSocketMultiplexer;
 	CTCPSocketFactory* clientSocketFactory = new CTCPSocketFactory(&m_events, &clientSocketMultiplexer);
 	
 	ON_CALL(clientScreen, getShape(_, _, _, _)).WillByDefault(Invoke(getScreenShape));
 	ON_CALL(clientScreen, getCursorPos(_, _)).WillByDefault(Invoke(getCursorPos));
 
-	CClient client(&m_events, "stub", serverAddress, clientSocketFactory, NULL, &clientScreen, cryptoOptions, true);
+	Client client(&m_events, "stub", serverAddress, clientSocketFactory, NULL, &clientScreen, cryptoOptions, true);
 		
 	m_events.adoptHandler(
 		m_events.forIScreen().fileRecieveCompleted(), &client,
@@ -206,7 +206,7 @@ TEST_F(NetworkTests, sendToClient_mockFile)
 
 	m_events.initQuitTimeout(10);
 	m_events.loop();
-	m_events.removeHandler(m_events.forCClientListener().connected(), &listener);
+	m_events.removeHandler(m_events.forClientListener().connected(), &listener);
 	m_events.removeHandler(m_events.forIScreen().fileRecieveCompleted(), &client);
 	m_events.cleanupQuitTimeout();
 }
@@ -214,39 +214,39 @@ TEST_F(NetworkTests, sendToClient_mockFile)
 TEST_F(NetworkTests, sendToServer_mockData)
 {
 	// server and client
-	CNetworkAddress serverAddress(TEST_HOST, TEST_PORT);
-	CCryptoOptions cryptoOptions;
+	NetworkAddress serverAddress(TEST_HOST, TEST_PORT);
+	CryptoOptions cryptoOptions;
 	
 	serverAddress.resolve();
 
 	// server
-	CSocketMultiplexer serverSocketMultiplexer;
+	SocketMultiplexer serverSocketMultiplexer;
 	CTCPSocketFactory* serverSocketFactory = new CTCPSocketFactory(&m_events, &serverSocketMultiplexer);
-	CClientListener listener(serverAddress, serverSocketFactory, NULL, cryptoOptions, &m_events);
-	NiceMock<CMockScreen> serverScreen;
-	NiceMock<CMockPrimaryClient> primaryClient;
-	NiceMock<CMockConfig> serverConfig;
-	NiceMock<CMockInputFilter> serverInputFilter;
+	ClientListener listener(serverAddress, serverSocketFactory, NULL, cryptoOptions, &m_events);
+	NiceMock<MockScreen> serverScreen;
+	NiceMock<MockPrimaryClient> primaryClient;
+	NiceMock<MockConfig> serverConfig;
+	NiceMock<MockInputFilter> serverInputFilter;
 
 	ON_CALL(serverConfig, isScreen(_)).WillByDefault(Return(true));
 	ON_CALL(serverConfig, getInputFilter()).WillByDefault(Return(&serverInputFilter));
 	
-	CServer server(serverConfig, &primaryClient, &serverScreen, &m_events, true);
+	Server server(serverConfig, &primaryClient, &serverScreen, &m_events, true);
 	server.m_mock = true;
 	listener.setServer(&server);
 
 	// client
-	NiceMock<CMockScreen> clientScreen;
-	CSocketMultiplexer clientSocketMultiplexer;
+	NiceMock<MockScreen> clientScreen;
+	SocketMultiplexer clientSocketMultiplexer;
 	CTCPSocketFactory* clientSocketFactory = new CTCPSocketFactory(&m_events, &clientSocketMultiplexer);
 	
 	ON_CALL(clientScreen, getShape(_, _, _, _)).WillByDefault(Invoke(getScreenShape));
 	ON_CALL(clientScreen, getCursorPos(_, _)).WillByDefault(Invoke(getCursorPos));
 
-	CClient client(&m_events, "stub", serverAddress, clientSocketFactory, NULL, &clientScreen, cryptoOptions, true);
+	Client client(&m_events, "stub", serverAddress, clientSocketFactory, NULL, &clientScreen, cryptoOptions, true);
 	
 	m_events.adoptHandler(
-		m_events.forCClientListener().connected(), &listener,
+		m_events.forClientListener().connected(), &listener,
 		new TMethodEventJob<NetworkTests>(
 			this, &NetworkTests::sendToServer_mockData_handleClientConnected, &client));
 
@@ -259,7 +259,7 @@ TEST_F(NetworkTests, sendToServer_mockData)
 
 	m_events.initQuitTimeout(10);
 	m_events.loop();
-	m_events.removeHandler(m_events.forCClientListener().connected(), &listener);
+	m_events.removeHandler(m_events.forClientListener().connected(), &listener);
 	m_events.removeHandler(m_events.forIScreen().fileRecieveCompleted(), &server);
 	m_events.cleanupQuitTimeout();
 }
@@ -267,39 +267,39 @@ TEST_F(NetworkTests, sendToServer_mockData)
 TEST_F(NetworkTests, sendToServer_mockFile)
 {
 	// server and client
-	CNetworkAddress serverAddress(TEST_HOST, TEST_PORT);
-	CCryptoOptions cryptoOptions;
+	NetworkAddress serverAddress(TEST_HOST, TEST_PORT);
+	CryptoOptions cryptoOptions;
 	
 	serverAddress.resolve();
 
 	// server
-	CSocketMultiplexer serverSocketMultiplexer;
+	SocketMultiplexer serverSocketMultiplexer;
 	CTCPSocketFactory* serverSocketFactory = new CTCPSocketFactory(&m_events, &serverSocketMultiplexer);
-	CClientListener listener(serverAddress, serverSocketFactory, NULL, cryptoOptions, &m_events);
-	NiceMock<CMockScreen> serverScreen;
-	NiceMock<CMockPrimaryClient> primaryClient;
-	NiceMock<CMockConfig> serverConfig;
-	NiceMock<CMockInputFilter> serverInputFilter;
+	ClientListener listener(serverAddress, serverSocketFactory, NULL, cryptoOptions, &m_events);
+	NiceMock<MockScreen> serverScreen;
+	NiceMock<MockPrimaryClient> primaryClient;
+	NiceMock<MockConfig> serverConfig;
+	NiceMock<MockInputFilter> serverInputFilter;
 
 	ON_CALL(serverConfig, isScreen(_)).WillByDefault(Return(true));
 	ON_CALL(serverConfig, getInputFilter()).WillByDefault(Return(&serverInputFilter));
 	
-	CServer server(serverConfig, &primaryClient, &serverScreen, &m_events, true);
+	Server server(serverConfig, &primaryClient, &serverScreen, &m_events, true);
 	server.m_mock = true;
 	listener.setServer(&server);
 
 	// client
-	NiceMock<CMockScreen> clientScreen;
-	CSocketMultiplexer clientSocketMultiplexer;
+	NiceMock<MockScreen> clientScreen;
+	SocketMultiplexer clientSocketMultiplexer;
 	CTCPSocketFactory* clientSocketFactory = new CTCPSocketFactory(&m_events, &clientSocketMultiplexer);
 	
 	ON_CALL(clientScreen, getShape(_, _, _, _)).WillByDefault(Invoke(getScreenShape));
 	ON_CALL(clientScreen, getCursorPos(_, _)).WillByDefault(Invoke(getCursorPos));
 
-	CClient client(&m_events, "stub", serverAddress, clientSocketFactory, NULL, &clientScreen, cryptoOptions, true);
+	Client client(&m_events, "stub", serverAddress, clientSocketFactory, NULL, &clientScreen, cryptoOptions, true);
 	
 	m_events.adoptHandler(
-		m_events.forCClientListener().connected(), &listener,
+		m_events.forClientListener().connected(), &listener,
 		new TMethodEventJob<NetworkTests>(
 			this, &NetworkTests::sendToServer_mockFile_handleClientConnected, &client));
 
@@ -312,23 +312,23 @@ TEST_F(NetworkTests, sendToServer_mockFile)
 
 	m_events.initQuitTimeout(10);
 	m_events.loop();
-	m_events.removeHandler(m_events.forCClientListener().connected(), &listener);
+	m_events.removeHandler(m_events.forClientListener().connected(), &listener);
 	m_events.removeHandler(m_events.forIScreen().fileRecieveCompleted(), &server);
 	m_events.cleanupQuitTimeout();
 }
 
 void 
-NetworkTests::sendToClient_mockData_handleClientConnected(const CEvent&, void* vlistener)
+NetworkTests::sendToClient_mockData_handleClientConnected(const Event&, void* vlistener)
 {
-	CClientListener* listener = reinterpret_cast<CClientListener*>(vlistener);
-	CServer* server = listener->getServer();
+	ClientListener* listener = reinterpret_cast<ClientListener*>(vlistener);
+	Server* server = listener->getServer();
 
-	CClientProxy* client = listener->getNextClient();
+	ClientProxy* client = listener->getNextClient();
 	if (client == NULL) {
 		throw runtime_error("client is null");
 	}
 
-	CBaseClientProxy* bcp = reinterpret_cast<CBaseClientProxy*>(client);
+	BaseClientProxy* bcp = reinterpret_cast<BaseClientProxy*>(client);
 	server->adoptClient(bcp);
 	server->setActive(bcp);
 
@@ -336,26 +336,26 @@ NetworkTests::sendToClient_mockData_handleClientConnected(const CEvent&, void* v
 }
 
 void 
-NetworkTests::sendToClient_mockData_fileRecieveCompleted(const CEvent& event, void*)
+NetworkTests::sendToClient_mockData_fileRecieveCompleted(const Event& event, void*)
 {
-	CClient* client = reinterpret_cast<CClient*>(event.getTarget());
+	Client* client = reinterpret_cast<Client*>(event.getTarget());
 	EXPECT_TRUE(client->isReceivedFileSizeValid());
 
 	m_events.raiseQuitEvent();
 }
 
 void 
-NetworkTests::sendToClient_mockFile_handleClientConnected(const CEvent&, void* vlistener)
+NetworkTests::sendToClient_mockFile_handleClientConnected(const Event&, void* vlistener)
 {
-	CClientListener* listener = reinterpret_cast<CClientListener*>(vlistener);
-	CServer* server = listener->getServer();
+	ClientListener* listener = reinterpret_cast<ClientListener*>(vlistener);
+	Server* server = listener->getServer();
 
-	CClientProxy* client = listener->getNextClient();
+	ClientProxy* client = listener->getNextClient();
 	if (client == NULL) {
 		throw runtime_error("client is null");
 	}
 
-	CBaseClientProxy* bcp = reinterpret_cast<CBaseClientProxy*>(client);
+	BaseClientProxy* bcp = reinterpret_cast<BaseClientProxy*>(client);
 	server->adoptClient(bcp);
 	server->setActive(bcp);
 
@@ -363,41 +363,41 @@ NetworkTests::sendToClient_mockFile_handleClientConnected(const CEvent&, void* v
 }
 
 void 
-NetworkTests::sendToClient_mockFile_fileRecieveCompleted(const CEvent& event, void*)
+NetworkTests::sendToClient_mockFile_fileRecieveCompleted(const Event& event, void*)
 {
-	CClient* client = reinterpret_cast<CClient*>(event.getTarget());
+	Client* client = reinterpret_cast<Client*>(event.getTarget());
 	EXPECT_TRUE(client->isReceivedFileSizeValid());
 
 	m_events.raiseQuitEvent();
 }
 
 void 
-NetworkTests::sendToServer_mockData_handleClientConnected(const CEvent&, void* vclient)
+NetworkTests::sendToServer_mockData_handleClientConnected(const Event&, void* vclient)
 {
-	CClient* client = reinterpret_cast<CClient*>(vclient);
+	Client* client = reinterpret_cast<Client*>(vclient);
 	sendMockData(client);
 }
 
 void 
-NetworkTests::sendToServer_mockData_fileRecieveCompleted(const CEvent& event, void*)
+NetworkTests::sendToServer_mockData_fileRecieveCompleted(const Event& event, void*)
 {
-	CServer* server = reinterpret_cast<CServer*>(event.getTarget());
+	Server* server = reinterpret_cast<Server*>(event.getTarget());
 	EXPECT_TRUE(server->isReceivedFileSizeValid());
 
 	m_events.raiseQuitEvent();
 }
 
 void 
-NetworkTests::sendToServer_mockFile_handleClientConnected(const CEvent&, void* vclient)
+NetworkTests::sendToServer_mockFile_handleClientConnected(const Event&, void* vclient)
 {
-	CClient* client = reinterpret_cast<CClient*>(vclient);
+	Client* client = reinterpret_cast<Client*>(vclient);
 	client->sendFileToServer(kMockFilename);
 }
 
 void 
-NetworkTests::sendToServer_mockFile_fileRecieveCompleted(const CEvent& event, void*)
+NetworkTests::sendToServer_mockFile_fileRecieveCompleted(const Event& event, void*)
 {
-	CServer* server = reinterpret_cast<CServer*>(event.getTarget());
+	Server* server = reinterpret_cast<Server*>(event.getTarget());
 	EXPECT_TRUE(server->isReceivedFileSizeValid());
 
 	m_events.raiseQuitEvent();
@@ -407,15 +407,15 @@ void
 NetworkTests::sendMockData(void* eventTarget)
 {
 	// send first message (file size)
-	CString size = intToString(kMockDataSize);
+	String size = intToString(kMockDataSize);
 	size_t sizeLength = size.size();
-	CFileChunker::CFileChunk* sizeMessage = new CFileChunker::CFileChunk(sizeLength + 2);
+	FileChunker::FileChunk* sizeMessage = new FileChunker::FileChunk(sizeLength + 2);
 	char* chunkData = sizeMessage->m_chunk;
 
 	chunkData[0] = kFileStart;
 	memcpy(&chunkData[1], size.c_str(), sizeLength);
 	chunkData[sizeLength + 1] = '\0';
-	m_events.addEvent(CEvent(m_events.forIScreen().fileChunkSending(), eventTarget, sizeMessage));
+	m_events.addEvent(Event(m_events.forIScreen().fileChunkSending(), eventTarget, sizeMessage));
 
 	// send chunk messages with incrementing chunk size
 	size_t lastSize = 0;
@@ -429,13 +429,13 @@ NetworkTests::sendMockData(void* eventTarget)
 		}
 
 		// first byte is the chunk mark, last is \0
-		CFileChunker::CFileChunk* fileChunk = new CFileChunker::CFileChunk(chunkSize + 2);
+		FileChunker::FileChunk* fileChunk = new FileChunker::FileChunk(chunkSize + 2);
 		char* chunkData = fileChunk->m_chunk;
 
 		chunkData[0] = kFileChunk;
 		memcpy(&chunkData[1], &m_mockData[sentLength], chunkSize);
 		chunkData[chunkSize + 1] = '\0';
-		m_events.addEvent(CEvent(m_events.forIScreen().fileChunkSending(), eventTarget, fileChunk));
+		m_events.addEvent(Event(m_events.forIScreen().fileChunkSending(), eventTarget, fileChunk));
 
 		sentLength += chunkSize;
 		lastSize = chunkSize;
@@ -447,12 +447,12 @@ NetworkTests::sendMockData(void* eventTarget)
 	}
 	
 	// send last message
-	CFileChunker::CFileChunk* transferFinished = new CFileChunker::CFileChunk(2);
+	FileChunker::FileChunk* transferFinished = new FileChunker::FileChunk(2);
 	chunkData = transferFinished->m_chunk;
 
 	chunkData[0] = kFileEnd;
 	chunkData[1] = '\0';
-	m_events.addEvent(CEvent(m_events.forIScreen().fileChunkSending(), eventTarget, transferFinished));
+	m_events.addEvent(Event(m_events.forIScreen().fileChunkSending(), eventTarget, transferFinished));
 }
 
 UInt8*
@@ -519,7 +519,7 @@ getCursorPos(SInt32& x, SInt32& y)
 	y = 0;
 }
 
-CString
+String
 intToString(size_t i)
 {
 	stringstream ss;

src/test/integtests/platform/MSWindowsClipboardTests.cpp

@@ -89,7 +89,7 @@ TEST_F(CMSWindowsClipboardTests, add_newValue_valueWasStored)
 
 	clipboard.add(IClipboard::kText, "synergy rocks!");
 
-	CString actual = clipboard.get(IClipboard::kText);
+	String actual = clipboard.get(IClipboard::kText);
 	EXPECT_EQ("synergy rocks!", actual);
 }
 
@@ -113,7 +113,7 @@ TEST_F(CMSWindowsClipboardTests, add_replaceValue_valueWasReplaced)
 	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);
 }
 
@@ -154,7 +154,7 @@ TEST_F(CMSWindowsClipboardTests, close_isOpen_noErrors)
 
 	CMSWindowsClipboard::Time actual = clipboard.getTime();
 
-	// this behavior is different to that of CClipboard which only
+	// this behavior is different to that of Clipboard which only
 	// returns the value passed into open(t) after empty() is called.
 	EXPECT_EQ(1, actual);
 }*/
@@ -201,7 +201,7 @@ TEST_F(CMSWindowsClipboardTests, get_withNoFormats_returnsEmpty)
 	clipboard.open(0);
 	clipboard.empty();
 
-	CString actual = clipboard.get(IClipboard::kText);
+	String actual = clipboard.get(IClipboard::kText);
 
 	EXPECT_EQ("", actual);
 }
@@ -213,7 +213,7 @@ TEST_F(CMSWindowsClipboardTests, get_withFormatAdded_returnsExpected)
 	clipboard.empty();
 	clipboard.add(IClipboard::kText, "synergy rocks!");
 
-	CString actual = clipboard.get(IClipboard::kText);
+	String actual = clipboard.get(IClipboard::kText);
 
 	EXPECT_EQ("synergy rocks!", actual);
 }

src/test/integtests/platform/MSWindowsKeyStateTests.cpp

@@ -70,9 +70,9 @@ private:
 
 TEST_F(CMSWindowsKeyStateTests, disable_eventQueueNotUsed)
 {
-	NiceMock<CMockEventQueue> eventQueue;
+	NiceMock<MockEventQueue> eventQueue;
 	CMSWindowsDesks* desks = newDesks(&eventQueue);
-	CMockKeyMap keyMap;
+	MockKeyMap keyMap;
 	CMSWindowsKeyState keyState(desks, getEventTarget(), &eventQueue, keyMap);
 	
 	EXPECT_CALL(eventQueue, removeHandler(_, _)).Times(0);
@@ -83,9 +83,9 @@ TEST_F(CMSWindowsKeyStateTests, disable_eventQueueNotUsed)
 
 TEST_F(CMSWindowsKeyStateTests, testAutoRepeat_noRepeatAndButtonIsZero_resultIsTrue)
 {
-	NiceMock<CMockEventQueue> eventQueue;
+	NiceMock<MockEventQueue> eventQueue;
 	CMSWindowsDesks* desks = newDesks(&eventQueue);
-	CMockKeyMap keyMap;
+	MockKeyMap keyMap;
 	CMSWindowsKeyState keyState(desks, getEventTarget(), &eventQueue, keyMap);
 	keyState.setLastDown(1);
 
@@ -97,9 +97,9 @@ TEST_F(CMSWindowsKeyStateTests, testAutoRepeat_noRepeatAndButtonIsZero_resultIsT
 
 TEST_F(CMSWindowsKeyStateTests, testAutoRepeat_pressFalse_lastDownIsZero)
 {
-	NiceMock<CMockEventQueue> eventQueue;
+	NiceMock<MockEventQueue> eventQueue;
 	CMSWindowsDesks* desks = newDesks(&eventQueue);
-	CMockKeyMap keyMap;
+	MockKeyMap keyMap;
 	CMSWindowsKeyState keyState(desks, getEventTarget(), &eventQueue, keyMap);
 	keyState.setLastDown(1);
 
@@ -111,9 +111,9 @@ TEST_F(CMSWindowsKeyStateTests, testAutoRepeat_pressFalse_lastDownIsZero)
 
 TEST_F(CMSWindowsKeyStateTests, saveModifiers_noModifiers_savedModifiers0)
 {
-	NiceMock<CMockEventQueue> eventQueue;
+	NiceMock<MockEventQueue> eventQueue;
 	CMSWindowsDesks* desks = newDesks(&eventQueue);
-	CMockKeyMap keyMap;
+	MockKeyMap keyMap;
 	CMSWindowsKeyState keyState(desks, getEventTarget(), &eventQueue, keyMap);
 
 	keyState.saveModifiers();

src/test/integtests/platform/OSXClipboardTests.cpp

@@ -21,9 +21,9 @@
 #include "test/global/gtest.h"
 #include <iostream>
 
-TEST(COSXClipboardTests, empty_openCalled_returnsTrue)
+TEST(OSXClipboardTests, empty_openCalled_returnsTrue)
 {
-	COSXClipboard clipboard;
+	OSXClipboard clipboard;
 	clipboard.open(0);
 	
 	bool actual = clipboard.empty();
@@ -31,62 +31,62 @@ TEST(COSXClipboardTests, empty_openCalled_returnsTrue)
 	EXPECT_EQ(true, actual);
 }
 
-TEST(COSXClipboardTests, empty_singleFormat_hasReturnsFalse)
+TEST(OSXClipboardTests, empty_singleFormat_hasReturnsFalse)
 {
-	COSXClipboard clipboard;
+	OSXClipboard clipboard;
 	clipboard.open(0);
-	clipboard.add(COSXClipboard::kText, "synergy rocks!");
+	clipboard.add(OSXClipboard::kText, "synergy rocks!");
 	
 	clipboard.empty();
 	
-	bool actual = clipboard.has(COSXClipboard::kText);
+	bool actual = clipboard.has(OSXClipboard::kText);
 	EXPECT_EQ(false, actual);
 }
 
-TEST(COSXClipboardTests, add_newValue_valueWasStored)
+TEST(OSXClipboardTests, add_newValue_valueWasStored)
 {
-	COSXClipboard clipboard;
+	OSXClipboard 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(COSXClipboardTests, add_replaceValue_valueWasReplaced)
+TEST(OSXClipboardTests, add_replaceValue_valueWasReplaced)
 {
-	COSXClipboard clipboard;
+	OSXClipboard 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(COSXClipboardTests, open_timeIsZero_returnsTrue)
+TEST(OSXClipboardTests, open_timeIsZero_returnsTrue)
 {
-	COSXClipboard clipboard;
+	OSXClipboard clipboard;
 	
 	bool actual = clipboard.open(0);
 	
 	EXPECT_EQ(true, actual);
 }
 
-TEST(COSXClipboardTests, open_timeIsOne_returnsTrue)
+TEST(OSXClipboardTests, open_timeIsOne_returnsTrue)
 {
-	COSXClipboard clipboard;
+	OSXClipboard clipboard;
 	
 	bool actual = clipboard.open(1);
 	
 	EXPECT_EQ(true, actual);
 }
 
-TEST(COSXClipboardTests, close_isOpen_noErrors)
+TEST(OSXClipboardTests, close_isOpen_noErrors)
 {
-	COSXClipboard clipboard;
+	OSXClipboard clipboard;
 	clipboard.open(0);
 	
 	clipboard.close();
@@ -94,32 +94,32 @@ TEST(COSXClipboardTests, close_isOpen_noErrors)
 	// can't assert anything
 }
 
-TEST(COSXClipboardTests, getTime_openWithNoEmpty_returnsOne)
+TEST(OSXClipboardTests, getTime_openWithNoEmpty_returnsOne)
 {
-	COSXClipboard clipboard;
+	OSXClipboard clipboard;
 	clipboard.open(1);
 	
-	COSXClipboard::Time actual = clipboard.getTime();
+	OSXClipboard::Time actual = clipboard.getTime();
 	
-	// this behavior is different to that of CClipboard which only
+	// this behavior is different to that of Clipboard which only
 	// returns the value passed into open(t) after empty() is called.
 	EXPECT_EQ((UInt32)1, actual);
 }
 
-TEST(COSXClipboardTests, getTime_openAndEmpty_returnsOne)
+TEST(OSXClipboardTests, getTime_openAndEmpty_returnsOne)
 {
-	COSXClipboard clipboard;
+	OSXClipboard clipboard;
 	clipboard.open(1);
 	clipboard.empty();
 	
-	COSXClipboard::Time actual = clipboard.getTime();
+	OSXClipboard::Time actual = clipboard.getTime();
 	
 	EXPECT_EQ((UInt32)1, actual);
 }
 
-TEST(COSXClipboardTests, has_withFormatAdded_returnsTrue)
+TEST(OSXClipboardTests, has_withFormatAdded_returnsTrue)
 {
-	COSXClipboard clipboard;
+	OSXClipboard clipboard;
 	clipboard.open(0);
 	clipboard.empty();
 	clipboard.add(IClipboard::kText, "synergy rocks!");
@@ -129,9 +129,9 @@ TEST(COSXClipboardTests, has_withFormatAdded_returnsTrue)
 	EXPECT_EQ(true, actual);
 }
 
-TEST(COSXClipboardTests, has_withNoFormats_returnsFalse)
+TEST(OSXClipboardTests, has_withNoFormats_returnsFalse)
 {
-	COSXClipboard clipboard;
+	OSXClipboard clipboard;
 	clipboard.open(0);
 	clipboard.empty();
 	
@@ -140,25 +140,25 @@ TEST(COSXClipboardTests, has_withNoFormats_returnsFalse)
 	EXPECT_EQ(false, actual);
 }
 
-TEST(COSXClipboardTests, get_withNoFormats_returnsEmpty)
+TEST(OSXClipboardTests, get_withNoFormats_returnsEmpty)
 {
-	COSXClipboard clipboard;
+	OSXClipboard clipboard;
 	clipboard.open(0);
 	clipboard.empty();
 	
-	CString actual = clipboard.get(IClipboard::kText);
+	String actual = clipboard.get(IClipboard::kText);
 	
 	EXPECT_EQ("", actual);
 }
 
-TEST(COSXClipboardTests, get_withFormatAdded_returnsExpected)
+TEST(OSXClipboardTests, get_withFormatAdded_returnsExpected)
 {
-	COSXClipboard clipboard;
+	OSXClipboard clipboard;
 	clipboard.open(0);
 	clipboard.empty();
 	clipboard.add(IClipboard::kText, "synergy rocks!");
 	
-	CString actual = clipboard.get(IClipboard::kText);
+	String actual = clipboard.get(IClipboard::kText);
 	
 	EXPECT_EQ("synergy rocks!", actual);
 }

src/test/integtests/platform/OSXKeyStateTests.cpp

@@ -30,19 +30,19 @@
 #define A_CHAR_ID 0x00000061
 #define A_CHAR_BUTTON 001
 
-class COSXKeyStateTests : public ::testing::Test {
+class OSXKeyStateTests : public ::testing::Test {
 public:
-	static bool isKeyPressed(const COSXKeyState& keyState, KeyButton button);
+	static bool isKeyPressed(const OSXKeyState& keyState, KeyButton button);
 };
 
 // fakeAndPoll_shift seems to always fail on osx10.6
 #if __MAC_OS_X_VERSION_MIN_REQUIRED > 1060
 
-TEST_F(COSXKeyStateTests, fakeAndPoll_shift)
+TEST_F(OSXKeyStateTests, fakeAndPoll_shift)
 {
-	CKeyMap keyMap;
-	CMockEventQueue eventQueue;
-	COSXKeyState keyState(&eventQueue, keyMap);
+	synergy::KeyMap keyMap;
+	MockEventQueue eventQueue;
+	OSXKeyState keyState(&eventQueue, keyMap);
 	keyState.updateKeyMap();
 
 	keyState.fakeKeyDown(SHIFT_ID_L, 0, 1);
@@ -58,11 +58,11 @@ TEST_F(COSXKeyStateTests, fakeAndPoll_shift)
 	EXPECT_TRUE(!isKeyPressed(keyState, SHIFT_BUTTON));
 }
 
-TEST_F(COSXKeyStateTests, fakeAndPoll_charKey)
+TEST_F(OSXKeyStateTests, fakeAndPoll_charKey)
 {
-	CKeyMap keyMap;
-	CMockEventQueue eventQueue;
-	COSXKeyState keyState(&eventQueue, keyMap);
+	synergy::KeyMap keyMap;
+	MockEventQueue eventQueue;
+	OSXKeyState keyState(&eventQueue, keyMap);
 	keyState.updateKeyMap();
 
 	keyState.fakeKeyDown(A_CHAR_ID, 0, 1);
@@ -77,11 +77,11 @@ TEST_F(COSXKeyStateTests, fakeAndPoll_charKey)
 	keyState.fakeKeyUp(2);
 }
 
-TEST_F(COSXKeyStateTests, fakeAndPoll_charKeyAndModifier)
+TEST_F(OSXKeyStateTests, fakeAndPoll_charKeyAndModifier)
 {
-	CKeyMap keyMap;
-	CMockEventQueue eventQueue;
-	COSXKeyState keyState(&eventQueue, keyMap);
+	synergy::KeyMap keyMap;
+	MockEventQueue eventQueue;
+	OSXKeyState keyState(&eventQueue, keyMap);
 	keyState.updateKeyMap();
 
 	keyState.fakeKeyDown(A_CHAR_ID, KeyModifierShift, 1);
@@ -97,7 +97,7 @@ TEST_F(COSXKeyStateTests, fakeAndPoll_charKeyAndModifier)
 }
 
 bool
-COSXKeyStateTests::isKeyPressed(const COSXKeyState& keyState, KeyButton button)
+OSXKeyStateTests::isKeyPressed(const OSXKeyState& keyState, KeyButton button)
 {
 	// HACK: allow os to realize key state changes.
 	ARCH->sleep(.2);

src/test/integtests/platform/OSXScreenTests.cpp

@@ -23,10 +23,10 @@
 
 // disabling these tests - the return value of CGCursorIsVisible is unreliable.
 /*
-TEST(COSXScreenTests, hideCursor_notPrimary)
+TEST(OSXScreenTests, hideCursor_notPrimary)
 {
-	CEventQueue queue;
-	COSXScreen screen(true, false);
+	EventQueue queue;
+	OSXScreen screen(true, false);
 
 	screen.hideCursor();
 
@@ -36,10 +36,10 @@ TEST(COSXScreenTests, hideCursor_notPrimary)
 	ARCH->sleep(.1f);
 }
 
-TEST(COSXScreenTests, showCursor_notPrimary)
+TEST(OSXScreenTests, showCursor_notPrimary)
 {
-	CEventQueue queue;
-	COSXScreen screen(false, false);
+	EventQueue queue;
+	OSXScreen screen(false, false);
 
 	screen.showCursor();
 

src/test/integtests/platform/XWindowsClipboardTests.cpp

@@ -91,7 +91,7 @@ TEST_F(CXWindowsClipboardTests, add_newValue_valueWasStored)
 	
 	clipboard.add(IClipboard::kText, "synergy rocks!");
 	
-	CString actual = clipboard.get(IClipboard::kText);
+	String actual = clipboard.get(IClipboard::kText);
 	EXPECT_EQ("synergy rocks!", actual);
 }
 
@@ -102,7 +102,7 @@ TEST_F(CXWindowsClipboardTests, add_replaceValue_valueWasReplaced)
 	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);
 }
 
@@ -139,7 +139,7 @@ TEST_F(CXWindowsClipboardTests, get_withNoFormats_returnsEmpty)
 {
 	CXWindowsClipboard clipboard = createClipboard();
 	
-	CString actual = clipboard.get(IClipboard::kText);
+	String actual = clipboard.get(IClipboard::kText);
 	
 	EXPECT_EQ("", actual);
 }
@@ -149,7 +149,7 @@ TEST_F(CXWindowsClipboardTests, get_withFormatAdded_returnsExpected)
 	CXWindowsClipboard clipboard = createClipboard();
 	clipboard.add(IClipboard::kText, "synergy rocks!");
 	
-	CString actual = clipboard.get(IClipboard::kText);
+	String actual = clipboard.get(IClipboard::kText);
 	
 	EXPECT_EQ("synergy rocks!", actual);
 }

src/test/integtests/platform/XWindowsKeyStateTests.cpp

@@ -74,8 +74,8 @@ protected:
 
 TEST_F(CXWindowsKeyStateTests, setActiveGroup_pollAndSet_groupIsZero)
 {
-	CMockKeyMap keyMap;
-	CMockEventQueue eventQueue;
+	MockKeyMap keyMap;
+	MockEventQueue eventQueue;
 	CXWindowsKeyState keyState(
 		m_display, true, &eventQueue, keyMap);
 
@@ -86,8 +86,8 @@ TEST_F(CXWindowsKeyStateTests, setActiveGroup_pollAndSet_groupIsZero)
 
 TEST_F(CXWindowsKeyStateTests, setActiveGroup_poll_groupIsNotSet)
 {
-	CMockKeyMap keyMap;
-	CMockEventQueue eventQueue;
+	MockKeyMap keyMap;
+	MockEventQueue eventQueue;
 	CXWindowsKeyState keyState(
 		m_display, true, &eventQueue, keyMap);
 
@@ -98,8 +98,8 @@ TEST_F(CXWindowsKeyStateTests, setActiveGroup_poll_groupIsNotSet)
 
 TEST_F(CXWindowsKeyStateTests, setActiveGroup_customGroup_groupWasSet)
 {
-	CMockKeyMap keyMap;
-	CMockEventQueue eventQueue;
+	MockKeyMap keyMap;
+	MockEventQueue eventQueue;
 	CXWindowsKeyState keyState(
 		m_display, true, &eventQueue, keyMap);
 
@@ -110,8 +110,8 @@ TEST_F(CXWindowsKeyStateTests, setActiveGroup_customGroup_groupWasSet)
 
 TEST_F(CXWindowsKeyStateTests, mapModifiersFromX_zeroState_zeroMask)
 {
-	CMockKeyMap keyMap;
-	CMockEventQueue eventQueue;
+	MockKeyMap keyMap;
+	MockEventQueue eventQueue;
 	CXWindowsKeyState keyState(
 		m_display, true, &eventQueue, keyMap);
 
@@ -122,8 +122,8 @@ TEST_F(CXWindowsKeyStateTests, mapModifiersFromX_zeroState_zeroMask)
 
 TEST_F(CXWindowsKeyStateTests, mapModifiersToX_zeroMask_resultIsTrue)
 {
-	CMockKeyMap keyMap;
-	CMockEventQueue eventQueue;
+	MockKeyMap keyMap;
+	MockEventQueue eventQueue;
 	CXWindowsKeyState keyState(
 		m_display, true, &eventQueue, keyMap);
 
@@ -135,8 +135,8 @@ TEST_F(CXWindowsKeyStateTests, mapModifiersToX_zeroMask_resultIsTrue)
 
 TEST_F(CXWindowsKeyStateTests, fakeCtrlAltDel_default_returnsFalse)
 {
-	CMockKeyMap keyMap;
-	CMockEventQueue eventQueue;
+	MockKeyMap keyMap;
+	MockEventQueue eventQueue;
 	CXWindowsKeyState keyState(
 		m_display, true, &eventQueue, keyMap);
 
@@ -147,8 +147,8 @@ TEST_F(CXWindowsKeyStateTests, fakeCtrlAltDel_default_returnsFalse)
 
 TEST_F(CXWindowsKeyStateTests, pollActiveModifiers_defaultState_returnsZero)
 {
-	CMockKeyMap keyMap;
-	CMockEventQueue eventQueue;
+	MockKeyMap keyMap;
+	MockEventQueue eventQueue;
 	CXWindowsKeyState keyState(
 		m_display, true, &eventQueue, keyMap);
 
@@ -160,8 +160,8 @@ TEST_F(CXWindowsKeyStateTests, pollActiveModifiers_defaultState_returnsZero)
 #if 0 // TODO: fix, causes sigsegv
 TEST_F(CXWindowsKeyStateTests, pollActiveModifiers_shiftKeyDownThenUp_masksAreCorrect)
 {
-	CMockKeyMap keyMap;
-	CMockEventQueue eventQueue;
+	MockKeyMap keyMap;
+	MockEventQueue eventQueue;
 	CXWindowsKeyState keyState(
 		m_display, true, &eventQueue, keyMap);
 
@@ -193,8 +193,8 @@ TEST_F(CXWindowsKeyStateTests, pollActiveModifiers_shiftKeyDownThenUp_masksAreCo
 
 TEST_F(CXWindowsKeyStateTests, pollActiveGroup_defaultState_returnsZero)
 {
-	CMockKeyMap keyMap;
-	CMockEventQueue eventQueue;
+	MockKeyMap keyMap;
+	MockEventQueue eventQueue;
 	CXWindowsKeyState keyState(
 		m_display, true, &eventQueue, keyMap);
 
@@ -205,8 +205,8 @@ TEST_F(CXWindowsKeyStateTests, pollActiveGroup_defaultState_returnsZero)
 
 TEST_F(CXWindowsKeyStateTests, pollActiveGroup_positiveGroup_returnsGroup)
 {
-	CMockKeyMap keyMap;
-	CMockEventQueue eventQueue;
+	MockKeyMap keyMap;
+	MockEventQueue eventQueue;
 	CXWindowsKeyState keyState(
 		m_display, true, &eventQueue, keyMap);
 
@@ -220,8 +220,8 @@ TEST_F(CXWindowsKeyStateTests, pollActiveGroup_positiveGroup_returnsGroup)
 TEST_F(CXWindowsKeyStateTests, pollActiveGroup_xkb_areEqual)
 {
 #if HAVE_XKB_EXTENSION
-	CMockKeyMap keyMap;
-	CMockEventQueue eventQueue;
+	MockKeyMap keyMap;
+	MockEventQueue eventQueue;
 	CXWindowsKeyState keyState(
 		m_display, true, &eventQueue, keyMap);
 

src/test/integtests/platform/XWindowsScreenSaverTests.cpp

@@ -32,7 +32,7 @@ TEST(CXWindowsScreenSaverTests, activate_defaultScreen_todo)
 {
 	Display* display = XOpenDisplay(":0.0");
 	Window window = DefaultRootWindow(display);
-	CMockEventQueue eventQueue;
+	MockEventQueue eventQueue;
 	EXPECT_CALL(eventQueue, removeHandler(_, _)).Times(1);
 	CXWindowsScreenSaver screenSaver(
 		display, window, NULL, &eventQueue);

src/test/integtests/platform/XWindowsScreenTests.cpp

@@ -25,7 +25,7 @@ using ::testing::_;
 
 TEST(CXWindowsScreenTests, fakeMouseMove_nonPrimary_getCursorPosValuesCorrect)
 {
-	CMockEventQueue eventQueue;
+	MockEventQueue eventQueue;
 	EXPECT_CALL(eventQueue, adoptHandler(_, _, _)).Times(2);
 	EXPECT_CALL(eventQueue, adoptBuffer(_)).Times(2);
 	EXPECT_CALL(eventQueue, removeHandler(_, _)).Times(2);

src/test/mock/client/MockClient.h

@@ -26,12 +26,12 @@
 
 class IEventQueue;
 
-class CMockClient : public CClient
+class MockClient : public Client
 {
 public:
-	CMockClient() : CClient() { }
+	MockClient() : Client() { }
 	MOCK_METHOD2(mouseMove, void(SInt32, SInt32));
-	MOCK_METHOD1(setOptions, void(const COptionsList&));
+	MOCK_METHOD1(setOptions, void(const OptionsList&));
 	MOCK_METHOD0(handshakeComplete, void());
 	MOCK_METHOD1(setDecryptIv, void(const UInt8*));
 };

src/test/mock/io/MockCryptoStream.h

@@ -22,11 +22,11 @@
 
 #include "test/global/gmock.h"
 
-class CMockCryptoStream : public CCryptoStream
+class MockCryptoStream : public CryptoStream
 {
 public:
-	CMockCryptoStream(IEventQueue* eventQueue, IStream* stream) :
-		CCryptoStream(eventQueue, stream, CCryptoOptions("gcm", "stub"), false) { }
+	MockCryptoStream(IEventQueue* eventQueue, IStream* stream) :
+		CryptoStream(eventQueue, stream, CryptoOptions("gcm", "stub"), false) { }
 	MOCK_METHOD2(read, UInt32(void*, UInt32));
 	MOCK_METHOD2(write, void(const void*, UInt32));
 };

src/test/mock/io/MockStream.h

@@ -24,20 +24,20 @@
 
 class IEventQueue;
 
-class CMockStream : public synergy::IStream
+class MockStream : public synergy::IStream
 {
 public:
-	CMockStream() { }
+	MockStream() { }
 	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_METHOD0(getInputReadyEvent, CEvent::Type());
-	MOCK_METHOD0(getOutputErrorEvent, CEvent::Type());
-	MOCK_METHOD0(getInputShutdownEvent, CEvent::Type());
-	MOCK_METHOD0(getOutputShutdownEvent, CEvent::Type());
+	MOCK_METHOD0(getInputReadyEvent, Event::Type());
+	MOCK_METHOD0(getOutputErrorEvent, Event::Type());
+	MOCK_METHOD0(getInputShutdownEvent, Event::Type());
+	MOCK_METHOD0(getOutputShutdownEvent, Event::Type());
 	MOCK_CONST_METHOD0(getEventTarget, void*());
 	MOCK_CONST_METHOD0(isReady, bool());
 	MOCK_CONST_METHOD0(getSize, UInt32());

src/test/mock/server/MockConfig.h

@@ -23,10 +23,10 @@
 
 #include "test/global/gmock.h"
 
-class CMockConfig : public CConfig
+class MockConfig : public Config
 {
 public:
-	CMockConfig() : CConfig() { }
-	MOCK_METHOD0(getInputFilter, CInputFilter*());
-	MOCK_CONST_METHOD1(isScreen, bool(const CString&));
+	MockConfig() : Config() { }
+	MOCK_METHOD0(getInputFilter, InputFilter*());
+	MOCK_CONST_METHOD1(isScreen, bool(const String&));
 };

src/test/mock/server/MockInputFilter.h

@@ -23,8 +23,8 @@
 
 #include "test/global/gmock.h"
 
-class CMockInputFilter : public CInputFilter
+class MockInputFilter : public InputFilter
 {
 public:
-	 MOCK_METHOD1(setPrimaryClient, void(CPrimaryClient*));
+	 MOCK_METHOD1(setPrimaryClient, void(PrimaryClient*));
 };

src/test/mock/server/MockPrimaryClient.h

@@ -24,7 +24,7 @@
 
 #include "test/global/gmock.h"
 
-class CMockPrimaryClient : public CPrimaryClient
+class MockPrimaryClient : public PrimaryClient
 {
 public:
 	MOCK_CONST_METHOD0(getEventTarget, void*());
@@ -32,7 +32,7 @@ public:
 	MOCK_CONST_METHOD2(setJumpCursorPos, void(SInt32, SInt32));
 	MOCK_METHOD1(reconfigure, void(UInt32));
 	MOCK_METHOD0(resetOptions, void());
-	MOCK_METHOD1(setOptions, void(const COptionsList&));
+	MOCK_METHOD1(setOptions, void(const OptionsList&));
 	MOCK_METHOD0(enable, void());
 	MOCK_METHOD0(disable, void());
 	MOCK_METHOD2(registerHotKey, UInt32(KeyID, KeyModifierMask));

src/test/mock/server/MockServer.h

@@ -25,8 +25,8 @@
 
 class IEventQueue;
 
-class CMockServer : public CServer
+class MockServer : public Server
 {
 public:
-	CMockServer() : CServer() { }
+	MockServer() : Server() { }
 };

src/test/mock/synergy/MockApp.h

@@ -23,14 +23,14 @@
 
 #include "test/global/gmock.h"
 
-class CMockApp : public CApp
+class MockApp : public App
 {
 public:
-	CMockApp() : CApp(NULL, NULL, NULL) { }
+	MockApp() : App(NULL, NULL, NULL) { }
 
 	MOCK_METHOD0(help, void());
 	MOCK_METHOD0(loadConfig, void());
-	MOCK_METHOD1(loadConfig, bool(const CString&));
+	MOCK_METHOD1(loadConfig, bool(const String&));
 	MOCK_CONST_METHOD0(daemonInfo, const char*());
 	MOCK_CONST_METHOD0(daemonName, const char*());
 	MOCK_METHOD2(parseArgs, void(int, const char* const*));
@@ -40,5 +40,5 @@ public:
 	MOCK_METHOD0(startNode, void());
 	MOCK_METHOD0(mainLoop, int());
 	MOCK_METHOD2(foregroundStartup, int(int, char**));
-	MOCK_METHOD0(createScreen, CScreen*());
+	MOCK_METHOD0(createScreen, Screen*());
 };

src/test/mock/synergy/MockArgParser.h

@@ -23,10 +23,10 @@
 
 #include "test/global/gmock.h"
 
-class CMockArgParser : public CArgParser
+class MockArgParser : public ArgParser
 {
 public:
-	CMockArgParser() : CArgParser(NULL) { }
+	MockArgParser() : ArgParser(NULL) { }
 
 	MOCK_METHOD3(parseGenericArgs, bool(int, const char* const*, int&));
 	MOCK_METHOD0(checkUnexpectedArgs, bool());

src/test/mock/synergy/MockEventQueue.h

@@ -22,42 +22,42 @@
 
 #include "test/global/gmock.h"
 
-class CMockEventQueue : public IEventQueue
+class MockEventQueue : public IEventQueue
 {
 public:
 	MOCK_METHOD0(loop, void());
-	MOCK_METHOD2(newOneShotTimer, CEventQueueTimer*(double, void*));
-	MOCK_METHOD2(newTimer, CEventQueueTimer*(double, void*));
-	MOCK_METHOD2(getEvent, bool(CEvent&, double));
+	MOCK_METHOD2(newOneShotTimer, EventQueueTimer*(double, void*));
+	MOCK_METHOD2(newTimer, EventQueueTimer*(double, void*));
+	MOCK_METHOD2(getEvent, bool(Event&, double));
 	MOCK_METHOD1(adoptBuffer, void(IEventQueueBuffer*));
-	MOCK_METHOD2(registerTypeOnce, CEvent::Type(CEvent::Type&, const char*));
+	MOCK_METHOD2(registerTypeOnce, Event::Type(Event::Type&, const char*));
 	MOCK_METHOD1(removeHandlers, void(void*));
-	MOCK_METHOD1(registerType, CEvent::Type(const char*));
+	MOCK_METHOD1(registerType, Event::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&));
+	MOCK_METHOD3(adoptHandler, void(Event::Type, void*, IEventJob*));
+	MOCK_METHOD1(getTypeName, const char*(Event::Type));
+	MOCK_METHOD1(addEvent, void(const Event&));
+	MOCK_METHOD2(removeHandler, void(Event::Type, void*));
+	MOCK_METHOD1(dispatchEvent, bool(const Event&));
+	MOCK_CONST_METHOD2(getHandler, IEventJob*(Event::Type, void*));
+	MOCK_METHOD1(deleteTimer, void(EventQueueTimer*));
+	MOCK_CONST_METHOD1(getRegisteredType, Event::Type(const String&));
 	MOCK_METHOD0(getSystemTarget, void*());
-	MOCK_METHOD0(forCClient, CClientEvents&());
+	MOCK_METHOD0(forClient, ClientEvents&());
 	MOCK_METHOD0(forIStream, IStreamEvents&());
-	MOCK_METHOD0(forCIpcClient, CIpcClientEvents&());
-	MOCK_METHOD0(forCIpcClientProxy, CIpcClientProxyEvents&());
-	MOCK_METHOD0(forCIpcServer, CIpcServerEvents&());
-	MOCK_METHOD0(forCIpcServerProxy, CIpcServerProxyEvents&());
+	MOCK_METHOD0(forIpcClient, IpcClientEvents&());
+	MOCK_METHOD0(forIpcClientProxy, IpcClientProxyEvents&());
+	MOCK_METHOD0(forIpcServer, IpcServerEvents&());
+	MOCK_METHOD0(forIpcServerProxy, IpcServerProxyEvents&());
 	MOCK_METHOD0(forIDataSocket, IDataSocketEvents&());
 	MOCK_METHOD0(forIListenSocket, IListenSocketEvents&());
 	MOCK_METHOD0(forISocket, ISocketEvents&());
-	MOCK_METHOD0(forCOSXScreen, COSXScreenEvents&());
-	MOCK_METHOD0(forCClientListener, CClientListenerEvents&());
-	MOCK_METHOD0(forCClientProxy, CClientProxyEvents&());
-	MOCK_METHOD0(forCClientProxyUnknown, CClientProxyUnknownEvents&());
-	MOCK_METHOD0(forCServer, CServerEvents&());
-	MOCK_METHOD0(forCServerApp, CServerAppEvents&());
+	MOCK_METHOD0(forOSXScreen, OSXScreenEvents&());
+	MOCK_METHOD0(forClientListener, ClientListenerEvents&());
+	MOCK_METHOD0(forClientProxy, ClientProxyEvents&());
+	MOCK_METHOD0(forClientProxyUnknown, ClientProxyUnknownEvents&());
+	MOCK_METHOD0(forServer, ServerEvents&());
+	MOCK_METHOD0(forServerApp, ServerAppEvents&());
 	MOCK_METHOD0(forIKeyState, IKeyStateEvents&());
 	MOCK_METHOD0(forIPrimaryScreen, IPrimaryScreenEvents&());
 	MOCK_METHOD0(forIScreen, IScreenEvents&());

src/test/mock/synergy/MockKeyMap.h

@@ -22,15 +22,15 @@
 
 #include "test/global/gmock.h"
 
-class CMockKeyMap : public CKeyMap
+class MockKeyMap : public synergy::KeyMap
 {
 public:
-	MOCK_METHOD1(swap, void(CKeyMap&));
+	MOCK_METHOD1(swap, void(KeyMap&));
 	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*(
+	MOCK_CONST_METHOD7(mapKey, const KeyMap::KeyItem*(
 		Keystrokes&, KeyID, SInt32, ModifierToKeys&, KeyModifierMask&,
 		KeyModifierMask, bool));
 };

src/test/mock/synergy/MockScreen.h

@@ -23,14 +23,14 @@
 
 #include "test/global/gmock.h"
 
-class CMockScreen : public CScreen
+class MockScreen : public Screen
 {
 public:
-	CMockScreen() : CScreen() { }
+	MockScreen() : Screen() { }
 	MOCK_METHOD0(disable, void());
 	MOCK_CONST_METHOD4(getShape, void(SInt32&, SInt32&, SInt32&, SInt32&));
 	MOCK_CONST_METHOD2(getCursorPos, void(SInt32&, SInt32&));
 	MOCK_METHOD0(resetOptions, void());
-	MOCK_METHOD1(setOptions, void(const COptionsList&));
+	MOCK_METHOD1(setOptions, void(const OptionsList&));
 	MOCK_METHOD0(enable, void());
 };

src/test/unittests/Main.cpp

@@ -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);

src/test/unittests/base/StringTests.cpp

@@ -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);
 }

src/test/unittests/client/ServerProxyTests.cpp

@@ -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);

src/test/unittests/server/ClientProxyTests.cpp

@@ -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);

src/test/unittests/synergy/ArgParserTests.cpp

@@ -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);
 }

src/test/unittests/synergy/ClientArgsParsingTests.cpp

@@ -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"};
 

src/test/unittests/synergy/ClipboardTests.cpp

@@ -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);
 }

src/test/unittests/synergy/CryptoStreamTests.cpp

@@ -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]);
 

src/test/unittests/synergy/GenericArgsParsingTests.cpp

@@ -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);

src/test/unittests/synergy/KeyStateTests.cpp

@@ -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)

src/test/unittests/synergy/KeyStateTests.h

@@ -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;

src/test/unittests/synergy/ServerArgsParsingTests.cpp

@@ -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" };