Import Upstream version 2.0.0+dfsgupstream/2.0.0+dfsg

14 files changed, 2151 insertions, 0 deletions

diff --git a/src/test/integtests/CMakeLists.txt b/src/test/integtests/CMakeLists.txt
new file mode 100644
index 0000000..a412ecc
--- /dev/null
+++ b/src/test/integtests/CMakeLists.txt
@@ -0,0 +1,71 @@
+# barrier -- mouse and keyboard sharing utility
+# Copyright (C) 2012-2016 Symless Ltd.
+# Copyright (C) 2009 Nick Bolton
+# 
+# This package is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# found in the file LICENSE that should have accompanied this file.
+# 
+# This package is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+file(GLOB_RECURSE headers "*.h")
+file(GLOB_RECURSE sources "*.cpp")
+
+# remove platform files (specific platform added later).
+file(GLOB_RECURSE remove_platform "platform/*")
+list(REMOVE_ITEM headers ${remove_platform})
+list(REMOVE_ITEM sources ${remove_platform})
+
+# platform
+if (WIN32)
+    file(GLOB platform_sources "platform/MSWindows*.cpp")
+    file(GLOB platform_headers "platform/MSWindows*.h")
+elseif (APPLE)
+    file(GLOB platform_sources "platform/OSX*.cpp")
+    file(GLOB platform_headers "platform/OSX*.h")
+elseif (UNIX)
+    file(GLOB platform_sources "platform/XWindows*.cpp")
+    file(GLOB platform_headers "platform/XWindows*.h")
+endif()
+
+list(APPEND sources ${platform_sources})
+list(APPEND headers ${platform_headers})
+
+file(GLOB_RECURSE global_headers "../../test/global/*.h")
+file(GLOB_RECURSE global_sources "../../test/global/*.cpp")
+
+list(APPEND headers ${global_headers})
+list(APPEND sources ${global_sources})
+
+file(GLOB_RECURSE mock_headers "../../test/mock/*.h")
+file(GLOB_RECURSE mock_sources "../../test/mock/*.cpp")
+
+list(APPEND headers ${mock_headers})
+list(APPEND sources ${mock_sources})
+
+if (BARRIER_ADD_HEADERS)
+    list(APPEND sources ${headers})
+endif()
+
+include_directories(
+    ../../
+    ../../lib/
+    ../../../ext/gtest/include
+    ../../../ext/gmock/include
+)
+
+if (UNIX)
+    include_directories(
+        ../../..
+    )
+endif()
+
+add_executable(integtests ${sources})
+target_link_libraries(integtests
+    arch base client common io ipc mt net platform server barrier gtest gmock ${libs} ${OPENSSL_LIBS})
diff --git a/src/test/integtests/Main.cpp b/src/test/integtests/Main.cpp
new file mode 100644
index 0000000..76b42b6
--- /dev/null
+++ b/src/test/integtests/Main.cpp
@@ -0,0 +1,108 @@
+/*
+ * barrier -- mouse and keyboard sharing utility
+ * Copyright (C) 2012-2016 Symless Ltd.
+ * Copyright (C) 2011 Nick Bolton
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file LICENSE that should have accompanied this file.
+ * 
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "arch/Arch.h"
+#include "base/Log.h"
+
+#if SYSAPI_WIN32
+#include "arch/win32/ArchMiscWindows.h"
+#endif
+
+#include "test/global/gtest.h"
+#include <iostream>
+#include <fstream>
+
+#define LOCK_TIMEOUT 30
+
+using namespace std;
+
+void lock(string lockFile);
+void unlock(string lockFile);
+
+int
+main(int argc, char **argv)
+{
+#if SYSAPI_WIN32
+    // record window instance for tray icon, etc
+    ArchMiscWindows::setInstanceWin32(GetModuleHandle(NULL));
+#endif
+
+    Arch arch;
+    arch.init();
+    
+    Log log;
+    log.setFilter(kDEBUG2);
+
+    string lockFile;
+    for (int i = 0; i < argc; i++) {
+        if (string(argv[i]).compare("--lock-file") == 0) {
+            lockFile = argv[i + 1];
+        }
+    }
+
+    if (!lockFile.empty()) {
+        lock(lockFile);
+    }
+
+
+    testing::InitGoogleTest(&argc, argv);
+
+    int result = RUN_ALL_TESTS();
+
+    if (!lockFile.empty()) {
+        unlock(lockFile);
+    }
+  
+  // gtest seems to randomly finish with error codes (e.g. -1, -1073741819)
+  // even when no tests have failed. not sure what causes this, but it
+  // happens on all platforms and  keeps leading to false positives.
+  // according to the documentation, 1 is a failure, so we should be
+  // able to trust that code.
+  return (result == 1) ? 1 : 0;
+}
+
+void
+lock(string lockFile)
+{
+    double start = ARCH->time();
+    
+    // keep checking until timeout is reached.
+    while ((ARCH->time() - start) < LOCK_TIMEOUT) {
+
+        ifstream is(lockFile.c_str());
+        bool noLock = !is;
+        is.close();
+
+        if (noLock) {
+            break;
+        }
+
+        // check every second if file has gone.
+        ARCH->sleep(1);
+    }
+
+    // write empty lock file.
+    ofstream os(lockFile.c_str());
+    os.close();
+}
+
+void
+unlock(string lockFile) 
+{
+    remove(lockFile.c_str());
+}
diff --git a/src/test/integtests/arch/ArchInternetTests.cpp b/src/test/integtests/arch/ArchInternetTests.cpp
new file mode 100644
index 0000000..722df2f
--- /dev/null
+++ b/src/test/integtests/arch/ArchInternetTests.cpp
@@ -0,0 +1,37 @@
+/*
+ * barrier -- mouse and keyboard sharing utility
+ * Copyright (C) 2014-2016 Symless Ltd.
+ *
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file LICENSE that should have accompanied this file.
+ *
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "arch/Arch.h"
+
+#include "test/global/gtest.h"
+
+#define TEST_URL "https://symless.com/tests/?testString"
+//#define TEST_URL "http://localhost/barrier/tests/?testString"
+
+TEST(ArchInternetTests, get)
+{
+    ARCH_INTERNET internet;
+    String result = internet.get(TEST_URL);
+    ASSERT_EQ("Hello world!", result);
+}
+
+TEST(ArchInternetTests, urlEncode)
+{
+    ARCH_INTERNET internet;
+    String result = internet.urlEncode("hello=+&world");
+    ASSERT_EQ("hello%3D%2B%26world", result);
+}
diff --git a/src/test/integtests/ipc/IpcTests.cpp b/src/test/integtests/ipc/IpcTests.cpp
new file mode 100644
index 0000000..a0ee241
--- /dev/null
+++ b/src/test/integtests/ipc/IpcTests.cpp
@@ -0,0 +1,211 @@
+/*
+ * barrier -- mouse and keyboard sharing utility
+ * Copyright (C) 2012-2016 Symless Ltd.
+ * Copyright (C) 2012 Nick Bolton
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file LICENSE that should have accompanied this file.
+ * 
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// TODO: fix, tests failing intermittently on mac.
+#ifndef WINAPI_CARBON
+
+#define TEST_ENV
+
+#include "test/global/TestEventQueue.h"
+#include "ipc/IpcServer.h"
+#include "ipc/IpcClient.h"
+#include "ipc/IpcServerProxy.h"
+#include "ipc/IpcMessage.h"
+#include "ipc/IpcClientProxy.h"
+#include "ipc/Ipc.h"
+#include "net/SocketMultiplexer.h"
+#include "mt/Thread.h"
+#include "arch/Arch.h"
+#include "base/TMethodJob.h"
+#include "base/String.h"
+#include "base/Log.h"
+#include "base/EventQueue.h"
+#include "base/TMethodEventJob.h"
+
+#include "test/global/gtest.h"
+
+#define TEST_IPC_PORT 24802
+
+class IpcTests : public ::testing::Test
+{
+public:
+    IpcTests();
+    virtual ~IpcTests();
+    
+    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:
+    SocketMultiplexer    m_multiplexer;
+    bool                m_connectToServer_helloMessageReceived;
+    bool                m_connectToServer_hasClientNode;
+    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(IpcTests, connectToServer)
+{
+    SocketMultiplexer socketMultiplexer;
+    IpcServer server(&m_events, &socketMultiplexer, TEST_IPC_PORT);
+    server.listen();
+    m_connectToServer_server = &server;
+
+    m_events.adoptHandler(
+        m_events.forIpcServer().messageReceived(), &server,
+        new TMethodEventJob<IpcTests>(
+        this, &IpcTests::connectToServer_handleMessageReceived));
+    
+    IpcClient client(&m_events, &socketMultiplexer, TEST_IPC_PORT);
+    client.connect();
+    
+    m_events.initQuitTimeout(5);
+    m_events.loop();
+    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(IpcTests, sendMessageToServer)
+{
+    SocketMultiplexer socketMultiplexer;
+    IpcServer server(&m_events, &socketMultiplexer, TEST_IPC_PORT);
+    server.listen();
+    
+    // event handler sends "test" command to server.
+    m_events.adoptHandler(
+        m_events.forIpcServer().messageReceived(), &server,
+        new TMethodEventJob<IpcTests>(
+        this, &IpcTests::sendMessageToServer_serverHandleMessageReceived));
+    
+    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.forIpcServer().messageReceived(), &server);
+    m_events.cleanupQuitTimeout();
+
+    EXPECT_EQ("test", m_sendMessageToServer_receivedString);
+}
+
+TEST_F(IpcTests, sendMessageToClient)
+{
+    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.forIpcServer().messageReceived(), &server,
+        new TMethodEventJob<IpcTests>(
+        this, &IpcTests::sendMessageToClient_serverHandleClientConnected));
+
+    IpcClient client(&m_events, &socketMultiplexer, TEST_IPC_PORT);
+    client.connect();
+    
+    m_events.adoptHandler(
+        m_events.forIpcClient().messageReceived(), &client,
+        new TMethodEventJob<IpcTests>(
+        this, &IpcTests::sendMessageToClient_clientHandleMessageReceived));
+
+    m_events.initQuitTimeout(5);
+    m_events.loop();
+    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);
+}
+
+IpcTests::IpcTests() :
+m_connectToServer_helloMessageReceived(false),
+m_connectToServer_hasClientNode(false),
+m_connectToServer_server(nullptr),
+m_sendMessageToClient_server(nullptr),
+m_sendMessageToServer_client(nullptr)
+{
+}
+
+IpcTests::~IpcTests()
+{
+}
+
+void
+IpcTests::connectToServer_handleMessageReceived(const Event& e, void*)
+{
+    IpcMessage* m = static_cast<IpcMessage*>(e.getDataObject());
+    if (m->type() == kIpcHello) {
+        m_connectToServer_hasClientNode =
+            m_connectToServer_server->hasClients(kIpcClientNode);
+        m_connectToServer_helloMessageReceived = true;
+        m_events.raiseQuitEvent();
+    }
+}
+
+void
+IpcTests::sendMessageToServer_serverHandleMessageReceived(const Event& e, void*)
+{
+    IpcMessage* m = static_cast<IpcMessage*>(e.getDataObject());
+    if (m->type() == kIpcHello) {
+        LOG((CLOG_DEBUG "client said hello, sending test to server"));
+        IpcCommandMessage m("test", true);
+        m_sendMessageToServer_client->send(m);
+    }
+    else if (m->type() == kIpcCommand) {
+        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();
+    }
+}
+
+void
+IpcTests::sendMessageToClient_serverHandleClientConnected(const Event& e, void*)
+{
+    IpcMessage* m = static_cast<IpcMessage*>(e.getDataObject());
+    if (m->type() == kIpcHello) {
+        LOG((CLOG_DEBUG "client said hello, sending test to client"));
+        IpcLogLineMessage m("test");
+        m_sendMessageToClient_server->send(m, kIpcClientNode);
+    }
+}
+
+void
+IpcTests::sendMessageToClient_clientHandleMessageReceived(const Event& e, void*)
+{
+    IpcMessage* m = static_cast<IpcMessage*>(e.getDataObject());
+    if (m->type() == kIpcLogLine) {
+        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();
+    }
+}
+
+#endif // WINAPI_CARBON
diff --git a/src/test/integtests/net/NetworkTests.cpp b/src/test/integtests/net/NetworkTests.cpp
new file mode 100644
index 0000000..4a9a9f0
--- /dev/null
+++ b/src/test/integtests/net/NetworkTests.cpp
@@ -0,0 +1,525 @@
+/*
+ * barrier -- mouse and keyboard sharing utility
+ * Copyright (C) 2013-2016 Symless Ltd.
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file LICENSE that should have accompanied this file.
+ * 
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// TODO: fix, tests failing intermittently on mac.
+#ifndef WINAPI_CARBON
+
+#define TEST_ENV
+
+#include "test/mock/server/MockConfig.h"
+#include "test/mock/server/MockPrimaryClient.h"
+#include "test/mock/barrier/MockScreen.h"
+#include "test/mock/server/MockInputFilter.h"
+#include "test/global/TestEventQueue.h"
+#include "server/Server.h"
+#include "server/ClientListener.h"
+#include "server/ClientProxy.h"
+#include "client/Client.h"
+#include "barrier/FileChunk.h"
+#include "barrier/StreamChunker.h"
+#include "net/SocketMultiplexer.h"
+#include "net/NetworkAddress.h"
+#include "net/TCPSocketFactory.h"
+#include "mt/Thread.h"
+#include "base/TMethodEventJob.h"
+#include "base/TMethodJob.h"
+#include "base/Log.h"
+#include "common/stdexcept.h"
+
+#include "test/global/gtest.h"
+#include <sstream>
+#include <fstream>
+#include <iostream>
+#include <stdio.h>
+
+using namespace std;
+using ::testing::_;
+using ::testing::NiceMock;
+using ::testing::Return;
+using ::testing::Invoke;
+
+#define TEST_PORT 24803
+#define TEST_HOST "localhost"
+
+const size_t kMockDataSize = 1024 * 1024 * 10; // 10MB
+const UInt16 kMockDataChunkIncrement = 1024; // 1KB
+const char* kMockFilename = "NetworkTests.mock";
+const size_t kMockFileSize = 1024 * 1024 * 10; // 10MB
+
+void getScreenShape(SInt32& x, SInt32& y, SInt32& w, SInt32& h);
+void getCursorPos(SInt32& x, SInt32& y);
+UInt8* newMockData(size_t size);
+void createFile(fstream& file, const char* filename, size_t size);
+
+class NetworkTests : public ::testing::Test
+{
+public:
+    NetworkTests() :
+        m_mockData(NULL),
+        m_mockDataSize(0),
+        m_mockFileSize(0)
+    {
+        m_mockData = newMockData(kMockDataSize);
+        createFile(m_mockFile, kMockFilename, kMockFileSize);
+    }
+
+    ~NetworkTests()
+    {
+        remove(kMockFilename);
+        delete[] m_mockData;
+    }
+
+    void                sendMockData(void* eventTarget);
+    
+    void                sendToClient_mockData_handleClientConnected(const Event&, void* vlistener);
+    void                sendToClient_mockData_fileRecieveCompleted(const Event&, void*);
+    
+    void                sendToClient_mockFile_handleClientConnected(const Event&, void* vlistener);
+    void                sendToClient_mockFile_fileRecieveCompleted(const Event& event, void*);
+    
+    void                sendToServer_mockData_handleClientConnected(const Event&, void* vlistener);
+    void                sendToServer_mockData_fileRecieveCompleted(const Event& event, void*);
+
+    void                sendToServer_mockFile_handleClientConnected(const Event&, void* vlistener);
+    void                sendToServer_mockFile_fileRecieveCompleted(const Event& event, void*);
+    
+public:
+    TestEventQueue        m_events;
+    UInt8*                m_mockData;
+    size_t                m_mockDataSize;
+    fstream                m_mockFile;
+    size_t                m_mockFileSize;
+};
+
+TEST_F(NetworkTests, sendToClient_mockData)
+{
+    // server and client
+    NetworkAddress serverAddress(TEST_HOST, TEST_PORT);
+
+    serverAddress.resolve();
+    
+    // server
+    SocketMultiplexer serverSocketMultiplexer;
+    TCPSocketFactory* serverSocketFactory = new TCPSocketFactory(&m_events, &serverSocketMultiplexer);
+    ClientListener listener(serverAddress, serverSocketFactory, &m_events, false);
+    NiceMock<MockScreen> serverScreen;
+    NiceMock<MockPrimaryClient> primaryClient;
+    NiceMock<MockConfig> serverConfig;
+    NiceMock<MockInputFilter> serverInputFilter;
+    
+    m_events.adoptHandler(
+        m_events.forClientListener().connected(), &listener,
+        new TMethodEventJob<NetworkTests>(
+            this, &NetworkTests::sendToClient_mockData_handleClientConnected, &listener));
+
+    ON_CALL(serverConfig, isScreen(_)).WillByDefault(Return(true));
+    ON_CALL(serverConfig, getInputFilter()).WillByDefault(Return(&serverInputFilter));
+    
+    ServerArgs serverArgs;
+    serverArgs.m_enableDragDrop = true;
+    Server server(serverConfig, &primaryClient, &serverScreen, &m_events, serverArgs);
+    server.m_mock = true;
+    listener.setServer(&server);
+
+    // client
+    NiceMock<MockScreen> clientScreen;
+    SocketMultiplexer clientSocketMultiplexer;
+    TCPSocketFactory* clientSocketFactory = new TCPSocketFactory(&m_events, &clientSocketMultiplexer);
+    
+    ON_CALL(clientScreen, getShape(_, _, _, _)).WillByDefault(Invoke(getScreenShape));
+    ON_CALL(clientScreen, getCursorPos(_, _)).WillByDefault(Invoke(getCursorPos));
+
+
+    ClientArgs clientArgs;
+    clientArgs.m_enableDragDrop = true;
+    clientArgs.m_enableCrypto = false;
+    Client client(&m_events, "stub", serverAddress, clientSocketFactory, &clientScreen, clientArgs);
+        
+    m_events.adoptHandler(
+        m_events.forFile().fileRecieveCompleted(), &client,
+        new TMethodEventJob<NetworkTests>(
+            this, &NetworkTests::sendToClient_mockData_fileRecieveCompleted));
+
+    client.connect();
+
+    m_events.initQuitTimeout(10);
+    m_events.loop();
+    m_events.removeHandler(m_events.forClientListener().connected(), &listener);
+    m_events.removeHandler(m_events.forFile().fileRecieveCompleted(), &client);
+    m_events.cleanupQuitTimeout();
+}
+
+TEST_F(NetworkTests, sendToClient_mockFile)
+{
+    // server and client
+    NetworkAddress serverAddress(TEST_HOST, TEST_PORT);
+
+    serverAddress.resolve();
+    
+    // server
+    SocketMultiplexer serverSocketMultiplexer;
+    TCPSocketFactory* serverSocketFactory = new TCPSocketFactory(&m_events, &serverSocketMultiplexer);
+    ClientListener listener(serverAddress, serverSocketFactory, &m_events, false);
+    NiceMock<MockScreen> serverScreen;
+    NiceMock<MockPrimaryClient> primaryClient;
+    NiceMock<MockConfig> serverConfig;
+    NiceMock<MockInputFilter> serverInputFilter;
+    
+    m_events.adoptHandler(
+        m_events.forClientListener().connected(), &listener,
+        new TMethodEventJob<NetworkTests>(
+            this, &NetworkTests::sendToClient_mockFile_handleClientConnected, &listener));
+
+    ON_CALL(serverConfig, isScreen(_)).WillByDefault(Return(true));
+    ON_CALL(serverConfig, getInputFilter()).WillByDefault(Return(&serverInputFilter));
+    
+    ServerArgs serverArgs;
+    serverArgs.m_enableDragDrop = true;
+    Server server(serverConfig, &primaryClient, &serverScreen, &m_events, serverArgs);
+    server.m_mock = true;
+    listener.setServer(&server);
+
+    // client
+    NiceMock<MockScreen> clientScreen;
+    SocketMultiplexer clientSocketMultiplexer;
+    TCPSocketFactory* clientSocketFactory = new TCPSocketFactory(&m_events, &clientSocketMultiplexer);
+    
+    ON_CALL(clientScreen, getShape(_, _, _, _)).WillByDefault(Invoke(getScreenShape));
+    ON_CALL(clientScreen, getCursorPos(_, _)).WillByDefault(Invoke(getCursorPos));
+
+
+    ClientArgs clientArgs;
+    clientArgs.m_enableDragDrop = true;
+    clientArgs.m_enableCrypto = false;
+    Client client(&m_events, "stub", serverAddress, clientSocketFactory, &clientScreen, clientArgs);
+        
+    m_events.adoptHandler(
+        m_events.forFile().fileRecieveCompleted(), &client,
+        new TMethodEventJob<NetworkTests>(
+            this, &NetworkTests::sendToClient_mockFile_fileRecieveCompleted));
+
+    client.connect();
+
+    m_events.initQuitTimeout(10);
+    m_events.loop();
+    m_events.removeHandler(m_events.forClientListener().connected(), &listener);
+    m_events.removeHandler(m_events.forFile().fileRecieveCompleted(), &client);
+    m_events.cleanupQuitTimeout();
+}
+
+TEST_F(NetworkTests, sendToServer_mockData)
+{
+    // server and client
+    NetworkAddress serverAddress(TEST_HOST, TEST_PORT);
+    serverAddress.resolve();
+
+    // server
+    SocketMultiplexer serverSocketMultiplexer;
+    TCPSocketFactory* serverSocketFactory = new TCPSocketFactory(&m_events, &serverSocketMultiplexer);
+    ClientListener listener(serverAddress, serverSocketFactory, &m_events, false);
+    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));
+    
+    ServerArgs serverArgs;
+    serverArgs.m_enableDragDrop = true;
+    Server server(serverConfig, &primaryClient, &serverScreen, &m_events, serverArgs);
+    server.m_mock = true;
+    listener.setServer(&server);
+
+    // client
+    NiceMock<MockScreen> clientScreen;
+    SocketMultiplexer clientSocketMultiplexer;
+    TCPSocketFactory* clientSocketFactory = new TCPSocketFactory(&m_events, &clientSocketMultiplexer);
+    
+    ON_CALL(clientScreen, getShape(_, _, _, _)).WillByDefault(Invoke(getScreenShape));
+    ON_CALL(clientScreen, getCursorPos(_, _)).WillByDefault(Invoke(getCursorPos));
+
+    ClientArgs clientArgs;
+    clientArgs.m_enableDragDrop = true;
+    clientArgs.m_enableCrypto = false;
+    Client client(&m_events, "stub", serverAddress, clientSocketFactory, &clientScreen, clientArgs);
+    
+    m_events.adoptHandler(
+        m_events.forClientListener().connected(), &listener,
+        new TMethodEventJob<NetworkTests>(
+            this, &NetworkTests::sendToServer_mockData_handleClientConnected, &client));
+
+    m_events.adoptHandler(
+        m_events.forFile().fileRecieveCompleted(), &server,
+        new TMethodEventJob<NetworkTests>(
+            this, &NetworkTests::sendToServer_mockData_fileRecieveCompleted));
+
+    client.connect();
+
+    m_events.initQuitTimeout(10);
+    m_events.loop();
+    m_events.removeHandler(m_events.forClientListener().connected(), &listener);
+    m_events.removeHandler(m_events.forFile().fileRecieveCompleted(), &server);
+    m_events.cleanupQuitTimeout();
+}
+
+TEST_F(NetworkTests, sendToServer_mockFile)
+{
+    // server and client
+    NetworkAddress serverAddress(TEST_HOST, TEST_PORT);
+
+    serverAddress.resolve();
+
+    // server
+    SocketMultiplexer serverSocketMultiplexer;
+    TCPSocketFactory* serverSocketFactory = new TCPSocketFactory(&m_events, &serverSocketMultiplexer);
+    ClientListener listener(serverAddress, serverSocketFactory, &m_events, false);
+    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));
+    
+    ServerArgs serverArgs;
+    serverArgs.m_enableDragDrop = true;
+    Server server(serverConfig, &primaryClient, &serverScreen, &m_events, serverArgs);
+    server.m_mock = true;
+    listener.setServer(&server);
+
+    // client
+    NiceMock<MockScreen> clientScreen;
+    SocketMultiplexer clientSocketMultiplexer;
+    TCPSocketFactory* clientSocketFactory = new TCPSocketFactory(&m_events, &clientSocketMultiplexer);
+    
+    ON_CALL(clientScreen, getShape(_, _, _, _)).WillByDefault(Invoke(getScreenShape));
+    ON_CALL(clientScreen, getCursorPos(_, _)).WillByDefault(Invoke(getCursorPos));
+
+    ClientArgs clientArgs;
+    clientArgs.m_enableDragDrop = true;
+    clientArgs.m_enableCrypto = false;
+    Client client(&m_events, "stub", serverAddress, clientSocketFactory, &clientScreen, clientArgs);
+
+    m_events.adoptHandler(
+        m_events.forClientListener().connected(), &listener,
+        new TMethodEventJob<NetworkTests>(
+            this, &NetworkTests::sendToServer_mockFile_handleClientConnected, &client));
+
+    m_events.adoptHandler(
+        m_events.forFile().fileRecieveCompleted(), &server,
+        new TMethodEventJob<NetworkTests>(
+            this, &NetworkTests::sendToServer_mockFile_fileRecieveCompleted));
+
+    client.connect();
+
+    m_events.initQuitTimeout(10);
+    m_events.loop();
+    m_events.removeHandler(m_events.forClientListener().connected(), &listener);
+    m_events.removeHandler(m_events.forFile().fileRecieveCompleted(), &server);
+    m_events.cleanupQuitTimeout();
+}
+
+void 
+NetworkTests::sendToClient_mockData_handleClientConnected(const Event&, void* vlistener)
+{
+    ClientListener* listener = static_cast<ClientListener*>(vlistener);
+    Server* server = listener->getServer();
+
+    ClientProxy* client = listener->getNextClient();
+    if (client == NULL) {
+        throw runtime_error("client is null");
+    }
+
+    BaseClientProxy* bcp = client;
+    server->adoptClient(bcp);
+    server->setActive(bcp);
+
+    sendMockData(server);
+}
+
+void 
+NetworkTests::sendToClient_mockData_fileRecieveCompleted(const Event& event, void*)
+{
+    Client* client = static_cast<Client*>(event.getTarget());
+    EXPECT_TRUE(client->isReceivedFileSizeValid());
+
+    m_events.raiseQuitEvent();
+}
+
+void 
+NetworkTests::sendToClient_mockFile_handleClientConnected(const Event&, void* vlistener)
+{
+    ClientListener* listener = static_cast<ClientListener*>(vlistener);
+    Server* server = listener->getServer();
+
+    ClientProxy* client = listener->getNextClient();
+    if (client == NULL) {
+        throw runtime_error("client is null");
+    }
+
+    BaseClientProxy* bcp = client;
+    server->adoptClient(bcp);
+    server->setActive(bcp);
+
+    server->sendFileToClient(kMockFilename);
+}
+
+void 
+NetworkTests::sendToClient_mockFile_fileRecieveCompleted(const Event& event, void*)
+{
+    Client* client = static_cast<Client*>(event.getTarget());
+    EXPECT_TRUE(client->isReceivedFileSizeValid());
+
+    m_events.raiseQuitEvent();
+}
+
+void 
+NetworkTests::sendToServer_mockData_handleClientConnected(const Event&, void* vclient)
+{
+    Client* client = static_cast<Client*>(vclient);
+    sendMockData(client);
+}
+
+void 
+NetworkTests::sendToServer_mockData_fileRecieveCompleted(const Event& event, void*)
+{
+    Server* server = static_cast<Server*>(event.getTarget());
+    EXPECT_TRUE(server->isReceivedFileSizeValid());
+
+    m_events.raiseQuitEvent();
+}
+
+void 
+NetworkTests::sendToServer_mockFile_handleClientConnected(const Event&, void* vclient)
+{
+    Client* client = static_cast<Client*>(vclient);
+    client->sendFileToServer(kMockFilename);
+}
+
+void 
+NetworkTests::sendToServer_mockFile_fileRecieveCompleted(const Event& event, void*)
+{
+    Server* server = static_cast<Server*>(event.getTarget());
+    EXPECT_TRUE(server->isReceivedFileSizeValid());
+
+    m_events.raiseQuitEvent();
+}
+
+void 
+NetworkTests::sendMockData(void* eventTarget)
+{
+    // send first message (file size)
+    String size = barrier::string::sizeTypeToString(kMockDataSize);
+    FileChunk* sizeMessage = FileChunk::start(size);
+    
+    m_events.addEvent(Event(m_events.forFile().fileChunkSending(), eventTarget, sizeMessage));
+
+    // send chunk messages with incrementing chunk size
+    size_t lastSize = 0;
+    size_t sentLength = 0;
+    while (true) {
+        size_t dataSize = lastSize + kMockDataChunkIncrement;
+
+        // make sure we don't read too much from the mock data.
+        if (sentLength + dataSize > kMockDataSize) {
+            dataSize = kMockDataSize - sentLength;
+        }
+
+        // first byte is the chunk mark, last is \0
+        FileChunk* chunk = FileChunk::data(m_mockData, dataSize);
+        m_events.addEvent(Event(m_events.forFile().fileChunkSending(), eventTarget, chunk));
+
+        sentLength += dataSize;
+        lastSize = dataSize;
+
+        if (sentLength == kMockDataSize) {
+            break;
+        }
+
+    }
+    
+    // send last message
+    FileChunk* transferFinished = FileChunk::end();
+    m_events.addEvent(Event(m_events.forFile().fileChunkSending(), eventTarget, transferFinished));
+}
+
+UInt8*
+newMockData(size_t size)
+{
+    UInt8* buffer = new UInt8[size];
+
+    UInt8* data = buffer;
+    const UInt8 head[] = "mock head... ";
+    size_t headSize = sizeof(head) - 1;
+    const UInt8 tail[] = "... mock tail";
+    size_t tailSize = sizeof(tail) - 1;
+    const UInt8 barrierRocks[] = "barrier\0 rocks! ";
+    size_t barrierRocksSize = sizeof(barrierRocks) - 1;
+
+    memcpy(data, head, headSize);
+    data += headSize;
+
+    size_t times = (size - headSize - tailSize) / barrierRocksSize;
+    for (size_t i = 0; i < times; ++i) {
+        memcpy(data, barrierRocks, barrierRocksSize);
+        data += barrierRocksSize;
+    }
+
+    size_t remainder = (size - headSize - tailSize) % barrierRocksSize;
+    if (remainder != 0) {
+        memset(data, '.', remainder);
+        data += remainder;
+    }
+
+    memcpy(data, tail, tailSize);
+    return buffer;
+}
+
+void
+createFile(fstream& file, const char* filename, size_t size)
+{
+    UInt8* buffer = newMockData(size);
+
+    file.open(filename, ios::out | ios::binary);
+    if (!file.is_open()) {
+        throw runtime_error("file not open");
+    }
+
+    file.write(reinterpret_cast<char*>(buffer), size);
+    file.close();
+
+    delete[] buffer;
+}
+
+void
+getScreenShape(SInt32& x, SInt32& y, SInt32& w, SInt32& h)
+{
+    x = 0;
+    y = 0;
+    w = 1;
+    h = 1;
+}
+
+void
+getCursorPos(SInt32& x, SInt32& y)
+{
+    x = 0;
+    y = 0;
+}
+
+#endif // WINAPI_CARBON
diff --git a/src/test/integtests/platform/MSWindowsClipboardTests.cpp b/src/test/integtests/platform/MSWindowsClipboardTests.cpp
new file mode 100644
index 0000000..f9d09d1
--- /dev/null
+++ b/src/test/integtests/platform/MSWindowsClipboardTests.cpp
@@ -0,0 +1,229 @@
+/*
+ * barrier -- mouse and keyboard sharing utility
+ * Copyright (C) 2012-2016 Symless Ltd.
+ * Copyright (C) 2011 Nick Bolton
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file LICENSE that should have accompanied this file.
+ * 
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "platform/MSWindowsClipboard.h"
+#include "platform/IMSWindowsClipboardFacade.h"
+
+#include "test/global/gmock.h"
+#include "test/global/gtest.h"
+
+class MSWindowsClipboardTests : public ::testing::Test
+{
+protected:
+    virtual void SetUp()
+    {
+        emptyClipboard();
+    }
+
+    virtual void TearDown()
+    {
+        emptyClipboard();
+    }
+
+private:
+    void emptyClipboard() 
+    {
+        MSWindowsClipboard clipboard(NULL);
+        clipboard.open(0);
+        clipboard.empty();
+    }
+};
+
+class MockFacade : public IMSWindowsClipboardFacade
+{
+public:
+    MOCK_METHOD2(write, void(HANDLE, UINT));
+};
+
+TEST_F(MSWindowsClipboardTests, emptyUnowned_openCalled_returnsTrue)
+{
+    MSWindowsClipboard clipboard(NULL);
+    clipboard.open(0);
+
+    bool actual = clipboard.emptyUnowned();
+
+    EXPECT_EQ(true, actual);
+}
+
+TEST_F(MSWindowsClipboardTests, empty_openCalled_returnsTrue)
+{
+    MSWindowsClipboard clipboard(NULL);
+    clipboard.open(0);
+
+    bool actual = clipboard.empty();
+
+    EXPECT_EQ(true, actual);
+}
+
+TEST_F(MSWindowsClipboardTests, empty_singleFormat_hasReturnsFalse)
+{
+    MSWindowsClipboard clipboard(NULL);
+    clipboard.open(0);
+    clipboard.add(MSWindowsClipboard::kText, "barrier rocks!");
+
+    clipboard.empty();
+
+    bool actual = clipboard.has(MSWindowsClipboard::kText);
+    EXPECT_EQ(false, actual);
+}
+
+TEST_F(MSWindowsClipboardTests, add_newValue_valueWasStored)
+{
+    MSWindowsClipboard clipboard(NULL);
+    clipboard.open(0);
+
+    clipboard.add(IClipboard::kText, "barrier rocks!");
+
+    String actual = clipboard.get(IClipboard::kText);
+    EXPECT_EQ("barrier rocks!", actual);
+}
+
+TEST_F(MSWindowsClipboardTests, add_newValue_writeWasCalled)
+{
+    MockFacade facade;
+    EXPECT_CALL(facade, write(testing::_, testing::_));
+
+    MSWindowsClipboard clipboard(NULL);
+    clipboard.setFacade(facade);
+    clipboard.open(0);
+
+    clipboard.add(IClipboard::kText, "barrier rocks!");
+}
+
+TEST_F(MSWindowsClipboardTests, add_replaceValue_valueWasReplaced)
+{
+    MSWindowsClipboard clipboard(NULL);
+    clipboard.open(0);
+
+    clipboard.add(IClipboard::kText, "barrier rocks!");
+    clipboard.add(IClipboard::kText, "maxivista sucks"); // haha, just kidding.
+
+    String actual = clipboard.get(IClipboard::kText);
+    EXPECT_EQ("maxivista sucks", actual);
+}
+
+TEST_F(MSWindowsClipboardTests, open_timeIsZero_returnsTrue)
+{
+    MSWindowsClipboard clipboard(NULL);
+
+    bool actual = clipboard.open(0);
+
+    EXPECT_EQ(true, actual);
+}
+
+TEST_F(MSWindowsClipboardTests, open_timeIsOne_returnsTrue)
+{
+    MSWindowsClipboard clipboard(NULL);
+
+    bool actual = clipboard.open(1);
+
+    EXPECT_EQ(true, actual);
+}
+
+TEST_F(MSWindowsClipboardTests, close_isOpen_noErrors)
+{
+    MSWindowsClipboard clipboard(NULL);
+    clipboard.open(0);
+
+    clipboard.close();
+
+    // can't assert anything
+}
+
+// looks like this test may fail intermittently:
+// * http://buildbot.symless.com:8000/builders/trunk-win32/builds/246/steps/shell_3/logs/stdio
+/*TEST_F(MSWindowsClipboardTests, getTime_openWithNoEmpty_returnsOne)
+{
+    MSWindowsClipboard clipboard(NULL);
+    clipboard.open(1);
+
+    MSWindowsClipboard::Time actual = clipboard.getTime();
+
+    // 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);
+}*/
+
+// this also fails intermittently:
+// http://buildbot.symless.com:8000/builders/trunk-win32/builds/266/steps/shell_3/logs/stdio
+/*TEST_F(MSWindowsClipboardTests, getTime_openAndEmpty_returnsOne)
+{
+    MSWindowsClipboard clipboard(NULL);
+    clipboard.open(1);
+    clipboard.empty();
+
+    MSWindowsClipboard::Time actual = clipboard.getTime();
+
+    EXPECT_EQ(1, actual);
+}*/
+
+TEST_F(MSWindowsClipboardTests, has_withFormatAdded_returnsTrue)
+{
+    MSWindowsClipboard clipboard(NULL);
+    clipboard.open(0);
+    clipboard.empty();
+    clipboard.add(IClipboard::kText, "barrier rocks!");
+
+    bool actual = clipboard.has(IClipboard::kText);
+
+    EXPECT_EQ(true, actual);
+}
+
+TEST_F(MSWindowsClipboardTests, has_withNoFormats_returnsFalse)
+{
+    MSWindowsClipboard clipboard(NULL);
+    clipboard.open(0);
+    clipboard.empty();
+
+    bool actual = clipboard.has(IClipboard::kText);
+
+    EXPECT_EQ(false, actual);
+}
+
+TEST_F(MSWindowsClipboardTests, get_withNoFormats_returnsEmpty)
+{
+    MSWindowsClipboard clipboard(NULL);
+    clipboard.open(0);
+    clipboard.empty();
+
+    String actual = clipboard.get(IClipboard::kText);
+
+    EXPECT_EQ("", actual);
+}
+
+TEST_F(MSWindowsClipboardTests, get_withFormatAdded_returnsExpected)
+{
+    MSWindowsClipboard clipboard(NULL);
+    clipboard.open(0);
+    clipboard.empty();
+    clipboard.add(IClipboard::kText, "barrier rocks!");
+
+    String actual = clipboard.get(IClipboard::kText);
+
+    EXPECT_EQ("barrier rocks!", actual);
+}
+
+TEST_F(MSWindowsClipboardTests, isOwnedByBarrier_defaultState_noError)
+{
+    MSWindowsClipboard clipboard(NULL);
+    clipboard.open(0);
+
+    bool actual = clipboard.isOwnedByBarrier();
+
+    EXPECT_EQ(true, actual);
+}
diff --git a/src/test/integtests/platform/MSWindowsKeyStateTests.cpp b/src/test/integtests/platform/MSWindowsKeyStateTests.cpp
new file mode 100644
index 0000000..f3f9e32
--- /dev/null
+++ b/src/test/integtests/platform/MSWindowsKeyStateTests.cpp
@@ -0,0 +1,144 @@
+/*
+ * barrier -- mouse and keyboard sharing utility
+ * Copyright (C) 2012-2016 Symless Ltd.
+ * Copyright (C) 2011 Nick Bolton
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file LICENSE that should have accompanied this file.
+ * 
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define TEST_ENV
+
+#include "test/mock/barrier/MockEventQueue.h"
+#include "test/mock/barrier/MockKeyMap.h"
+#include "platform/MSWindowsKeyState.h"
+#include "platform/MSWindowsDesks.h"
+#include "platform/MSWindowsScreen.h"
+#include "platform/MSWindowsScreenSaver.h"
+#include "base/TMethodJob.h"
+
+#include "test/global/gtest.h"
+#include "test/global/gmock.h"
+
+// wParam = flags, HIBYTE(lParam) = virtual key, LOBYTE(lParam) = scan code
+#define BARRIER_MSG_FAKE_KEY		BARRIER_HOOK_LAST_MSG + 4
+
+using ::testing::_;
+using ::testing::NiceMock;
+
+class MSWindowsKeyStateTests : public ::testing::Test
+{
+protected:
+	virtual void SetUp()
+	{
+		m_hook.loadLibrary();
+		m_screensaver = new MSWindowsScreenSaver();
+	}
+
+	virtual void TearDown()
+	{
+		delete m_screensaver;
+	}
+
+	MSWindowsDesks* newDesks(IEventQueue* eventQueue)
+	{
+		return new MSWindowsDesks(
+			true, false, m_screensaver, eventQueue,
+			new TMethodJob<MSWindowsKeyStateTests>(
+				this, &MSWindowsKeyStateTests::updateKeysCB), false);
+	}
+
+	void* getEventTarget() const
+	{
+		return const_cast<MSWindowsKeyStateTests*>(this);
+	}
+
+private:
+	void updateKeysCB(void*) { }
+	IScreenSaver* m_screensaver;
+	MSWindowsHook m_hook;
+};
+
+TEST_F(MSWindowsKeyStateTests, disable_eventQueueNotUsed)
+{
+	NiceMock<MockEventQueue> eventQueue;
+	MSWindowsDesks* desks = newDesks(&eventQueue);
+	MockKeyMap keyMap;
+	MSWindowsKeyState keyState(desks, getEventTarget(), &eventQueue, keyMap);
+	
+	EXPECT_CALL(eventQueue, removeHandler(_, _)).Times(0);
+
+	keyState.disable();
+	delete desks;
+}
+
+TEST_F(MSWindowsKeyStateTests, testAutoRepeat_noRepeatAndButtonIsZero_resultIsTrue)
+{
+	NiceMock<MockEventQueue> eventQueue;
+	MSWindowsDesks* desks = newDesks(&eventQueue);
+	MockKeyMap keyMap;
+	MSWindowsKeyState keyState(desks, getEventTarget(), &eventQueue, keyMap);
+	keyState.setLastDown(1);
+
+	bool actual = keyState.testAutoRepeat(true, false, 1);
+
+	ASSERT_TRUE(actual);
+	delete desks;
+}
+
+TEST_F(MSWindowsKeyStateTests, testAutoRepeat_pressFalse_lastDownIsZero)
+{
+	NiceMock<MockEventQueue> eventQueue;
+	MSWindowsDesks* desks = newDesks(&eventQueue);
+	MockKeyMap keyMap;
+	MSWindowsKeyState keyState(desks, getEventTarget(), &eventQueue, keyMap);
+	keyState.setLastDown(1);
+
+	keyState.testAutoRepeat(false, false, 1);
+
+	ASSERT_EQ(0, keyState.getLastDown());
+	delete desks;
+}
+
+TEST_F(MSWindowsKeyStateTests, saveModifiers_noModifiers_savedModifiers0)
+{
+	NiceMock<MockEventQueue> eventQueue;
+	MSWindowsDesks* desks = newDesks(&eventQueue);
+	MockKeyMap keyMap;
+	MSWindowsKeyState keyState(desks, getEventTarget(), &eventQueue, keyMap);
+
+	keyState.saveModifiers();
+
+	ASSERT_EQ(0, keyState.getSavedModifiers());
+	delete desks;
+}
+
+TEST_F(MSWindowsKeyStateTests, testKoreanLocale_inputModeKey_resultCorrectKeyID)
+{
+	NiceMock<MockEventQueue> eventQueue;
+	MSWindowsDesks* desks = newDesks(&eventQueue);
+	MockKeyMap keyMap;
+	MSWindowsKeyState keyState(desks, getEventTarget(), &eventQueue, keyMap);
+
+	keyState.setKeyLayout((HKL)0x00000412u);	// for ko-KR local ID
+	ASSERT_EQ(0xEF31, keyState.getKeyID(0x15u, 0x1f2u));	// VK_HANGUL from Hangul key
+	ASSERT_EQ(0xEF34, keyState.getKeyID(0x19u, 0x1f1u));	// VK_HANJA from Hanja key
+	ASSERT_EQ(0xEF31, keyState.getKeyID(0x15u, 0x11du));	// VK_HANGUL from R-Alt key
+	ASSERT_EQ(0xEF34, keyState.getKeyID(0x19u, 0x138u));	// VK_HANJA from R-Ctrl key
+
+	keyState.setKeyLayout((HKL)0x00000411); // for ja-jp locale ID
+	ASSERT_EQ(0xEF26, keyState.getKeyID(0x15u, 0x1du));	// VK_KANA
+	ASSERT_EQ(0xEF2A, keyState.getKeyID(0x19u, 0x38u));	// VK_KANJI
+
+	delete desks;
+}
+
diff --git a/src/test/integtests/platform/OSXClipboardTests.cpp b/src/test/integtests/platform/OSXClipboardTests.cpp
new file mode 100644
index 0000000..45b73bd
--- /dev/null
+++ b/src/test/integtests/platform/OSXClipboardTests.cpp
@@ -0,0 +1,164 @@
+/*
+ * barrier -- mouse and keyboard sharing utility
+ * Copyright (C) 2012-2016 Symless Ltd.
+ * Copyright (C) 2011 Nick Bolton
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file LICENSE that should have accompanied this file.
+ * 
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "platform/OSXClipboard.h"
+
+#include "test/global/gtest.h"
+#include <iostream>
+
+TEST(OSXClipboardTests, empty_openCalled_returnsTrue)
+{
+    OSXClipboard clipboard;
+    clipboard.open(0);
+    
+    bool actual = clipboard.empty();
+    
+    EXPECT_EQ(true, actual);
+}
+
+TEST(OSXClipboardTests, empty_singleFormat_hasReturnsFalse)
+{
+    OSXClipboard clipboard;
+    clipboard.open(0);
+    clipboard.add(OSXClipboard::kText, "barrier rocks!");
+    
+    clipboard.empty();
+    
+    bool actual = clipboard.has(OSXClipboard::kText);
+    EXPECT_EQ(false, actual);
+}
+
+TEST(OSXClipboardTests, add_newValue_valueWasStored)
+{
+    OSXClipboard clipboard;
+    clipboard.open(0);
+    
+    clipboard.add(IClipboard::kText, "barrier rocks!");
+    
+    String actual = clipboard.get(IClipboard::kText);
+    EXPECT_EQ("barrier rocks!", actual);
+}
+
+TEST(OSXClipboardTests, add_replaceValue_valueWasReplaced)
+{
+    OSXClipboard clipboard;
+    clipboard.open(0);
+    
+    clipboard.add(IClipboard::kText, "barrier rocks!");
+    clipboard.add(IClipboard::kText, "maxivista sucks"); // haha, just kidding.
+    
+    String actual = clipboard.get(IClipboard::kText);
+    EXPECT_EQ("maxivista sucks", actual);
+}
+
+TEST(OSXClipboardTests, open_timeIsZero_returnsTrue)
+{
+    OSXClipboard clipboard;
+    
+    bool actual = clipboard.open(0);
+    
+    EXPECT_EQ(true, actual);
+}
+
+TEST(OSXClipboardTests, open_timeIsOne_returnsTrue)
+{
+    OSXClipboard clipboard;
+    
+    bool actual = clipboard.open(1);
+    
+    EXPECT_EQ(true, actual);
+}
+
+TEST(OSXClipboardTests, close_isOpen_noErrors)
+{
+    OSXClipboard clipboard;
+    clipboard.open(0);
+    
+    clipboard.close();
+    
+    // can't assert anything
+}
+
+TEST(OSXClipboardTests, getTime_openWithNoEmpty_returnsOne)
+{
+    OSXClipboard clipboard;
+    clipboard.open(1);
+    
+    OSXClipboard::Time actual = clipboard.getTime();
+    
+    // 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(OSXClipboardTests, getTime_openAndEmpty_returnsOne)
+{
+    OSXClipboard clipboard;
+    clipboard.open(1);
+    clipboard.empty();
+    
+    OSXClipboard::Time actual = clipboard.getTime();
+    
+    EXPECT_EQ((UInt32)1, actual);
+}
+
+TEST(OSXClipboardTests, has_withFormatAdded_returnsTrue)
+{
+    OSXClipboard clipboard;
+    clipboard.open(0);
+    clipboard.empty();
+    clipboard.add(IClipboard::kText, "barrier rocks!");
+    
+    bool actual = clipboard.has(IClipboard::kText);
+    
+    EXPECT_EQ(true, actual);
+}
+
+TEST(OSXClipboardTests, has_withNoFormats_returnsFalse)
+{
+    OSXClipboard clipboard;
+    clipboard.open(0);
+    clipboard.empty();
+    
+    bool actual = clipboard.has(IClipboard::kText);
+    
+    EXPECT_EQ(false, actual);
+}
+
+TEST(OSXClipboardTests, get_withNoFormats_returnsEmpty)
+{
+    OSXClipboard clipboard;
+    clipboard.open(0);
+    clipboard.empty();
+    
+    String actual = clipboard.get(IClipboard::kText);
+    
+    EXPECT_EQ("", actual);
+}
+
+TEST(OSXClipboardTests, get_withFormatAdded_returnsExpected)
+{
+    OSXClipboard clipboard;
+    clipboard.open(0);
+    clipboard.empty();
+    clipboard.add(IClipboard::kText, "barrier rocks!");
+    
+    String actual = clipboard.get(IClipboard::kText);
+    
+    EXPECT_EQ("barrier rocks!", actual);
+}
diff --git a/src/test/integtests/platform/OSXKeyStateTests.cpp b/src/test/integtests/platform/OSXKeyStateTests.cpp
new file mode 100644
index 0000000..4957aaa
--- /dev/null
+++ b/src/test/integtests/platform/OSXKeyStateTests.cpp
@@ -0,0 +1,119 @@
+/*
+ * barrier -- mouse and keyboard sharing utility
+ * Copyright (C) 2012-2016 Symless Ltd.
+ * Copyright (C) 2011 Nick Bolton
+ *
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file LICENSE that should have accompanied this file.
+ *
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "test/mock/barrier/MockKeyMap.h"
+#include "test/mock/barrier/MockEventQueue.h"
+#include "platform/OSXKeyState.h"
+#include "base/Log.h"
+
+#include "test/global/gtest.h"
+#include "test/global/gmock.h"
+
+#define SHIFT_ID_L kKeyShift_L
+#define SHIFT_ID_R kKeyShift_R
+#define SHIFT_BUTTON 57
+#define A_CHAR_ID 0x00000061
+#define A_CHAR_BUTTON 001
+
+class OSXKeyStateTests : public ::testing::Test {
+public:
+    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(OSXKeyStateTests, fakeAndPoll_shift)
+{
+    barrier::KeyMap keyMap;
+    MockEventQueue eventQueue;
+    OSXKeyState keyState(&eventQueue, keyMap);
+    keyState.updateKeyMap();
+
+    keyState.fakeKeyDown(SHIFT_ID_L, 0, 1);
+    EXPECT_TRUE(isKeyPressed(keyState, SHIFT_BUTTON));
+
+    keyState.fakeKeyUp(1);
+    EXPECT_TRUE(!isKeyPressed(keyState, SHIFT_BUTTON));
+
+    keyState.fakeKeyDown(SHIFT_ID_R, 0, 2);
+    EXPECT_TRUE(isKeyPressed(keyState, SHIFT_BUTTON));
+
+    keyState.fakeKeyUp(2);
+    EXPECT_TRUE(!isKeyPressed(keyState, SHIFT_BUTTON));
+}
+
+TEST_F(OSXKeyStateTests, fakeAndPoll_charKey)
+{
+    barrier::KeyMap keyMap;
+    MockEventQueue eventQueue;
+    OSXKeyState keyState(&eventQueue, keyMap);
+    keyState.updateKeyMap();
+
+    keyState.fakeKeyDown(A_CHAR_ID, 0, 1);
+    EXPECT_TRUE(isKeyPressed(keyState, A_CHAR_BUTTON));
+
+    keyState.fakeKeyUp(1);
+    EXPECT_TRUE(!isKeyPressed(keyState, A_CHAR_BUTTON));
+
+    // HACK: delete the key in case it was typed into a text editor.
+    // we should really set focus to an invisible window.
+    keyState.fakeKeyDown(kKeyBackSpace, 0, 2);
+    keyState.fakeKeyUp(2);
+}
+
+TEST_F(OSXKeyStateTests, fakeAndPoll_charKeyAndModifier)
+{
+    barrier::KeyMap keyMap;
+    MockEventQueue eventQueue;
+    OSXKeyState keyState(&eventQueue, keyMap);
+    keyState.updateKeyMap();
+
+    keyState.fakeKeyDown(A_CHAR_ID, KeyModifierShift, 1);
+    EXPECT_TRUE(isKeyPressed(keyState, A_CHAR_BUTTON));
+
+    keyState.fakeKeyUp(1);
+    EXPECT_TRUE(!isKeyPressed(keyState, A_CHAR_BUTTON));
+
+    // HACK: delete the key in case it was typed into a text editor.
+    // we should really set focus to an invisible window.
+    keyState.fakeKeyDown(kKeyBackSpace, 0, 2);
+    keyState.fakeKeyUp(2);
+}
+
+bool
+OSXKeyStateTests::isKeyPressed(const OSXKeyState& keyState, KeyButton button)
+{
+    // HACK: allow os to realize key state changes.
+    ARCH->sleep(.2);
+
+    IKeyState::KeyButtonSet pressed;
+    keyState.pollPressedKeys(pressed);
+
+    IKeyState::KeyButtonSet::const_iterator it;
+    for (it = pressed.begin(); it != pressed.end(); ++it) {
+        LOG((CLOG_DEBUG "checking key %d", *it));
+        if (*it == button) {
+            return true;
+        }
+    }
+    return false;
+}
+
+#endif
+
diff --git a/src/test/integtests/platform/OSXScreenTests.cpp b/src/test/integtests/platform/OSXScreenTests.cpp
new file mode 100644
index 0000000..96beb4d
--- /dev/null
+++ b/src/test/integtests/platform/OSXScreenTests.cpp
@@ -0,0 +1,51 @@
+/*
+ * barrier -- mouse and keyboard sharing utility
+ * Copyright (C) 2012-2016 Symless Ltd.
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file LICENSE that should have accompanied this file.
+ * 
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "platform/OSXScreen.h"
+#include "arch/Arch.h"
+#include "base/EventQueue.h"
+
+#include "test/global/gtest.h"
+
+// disabling these tests - the return value of CGCursorIsVisible is unreliable.
+/*
+TEST(OSXScreenTests, hideCursor_notPrimary)
+{
+    EventQueue queue;
+    OSXScreen screen(true, false);
+
+    screen.hideCursor();
+
+    EXPECT_EQ(false, CGCursorIsVisible());
+
+    // workaround for screen class race condition.
+    ARCH->sleep(.1f);
+}
+
+TEST(OSXScreenTests, showCursor_notPrimary)
+{
+    EventQueue queue;
+    OSXScreen screen(false, false);
+
+    screen.showCursor();
+
+    EXPECT_EQ(true, CGCursorIsVisible());
+
+    // workaround for screen class race condition.
+    ARCH->sleep(.1f);
+}
+*/
diff --git a/src/test/integtests/platform/XWindowsClipboardTests.cpp b/src/test/integtests/platform/XWindowsClipboardTests.cpp
new file mode 100644
index 0000000..652ee5e
--- /dev/null
+++ b/src/test/integtests/platform/XWindowsClipboardTests.cpp
@@ -0,0 +1,157 @@
+/*
+ * barrier -- mouse and keyboard sharing utility
+ * Copyright (C) 2012-2016 Symless Ltd.
+ * Copyright (C) 2011 Nick Bolton
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file LICENSE that should have accompanied this file.
+ * 
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// TODO: fix tests - compile error on linux
+#if 0
+
+#include "platform/XWindowsClipboard.h"
+
+#include "test/global/gtest.h"
+#include <iostream>
+
+class CXWindowsClipboardTests : public ::testing::Test
+{
+protected:
+    virtual void
+    SetUp()
+    {
+        m_display = XOpenDisplay(NULL);
+        int screen = DefaultScreen(m_display);
+        Window root = XRootWindow(m_display, screen);
+        
+        XSetWindowAttributes attr;
+        attr.do_not_propagate_mask = 0;
+        attr.override_redirect = True;
+        attr.cursor = Cursor();
+        
+        m_window = XCreateWindow(
+            m_display, root, 0, 0, 1, 1, 0, 0,
+            InputOnly, CopyFromParent, 0, &attr);
+    }
+
+    virtual void
+    TearDown()
+    {
+        XDestroyWindow(m_display, m_window);
+        XCloseDisplay(m_display);
+    }
+
+    CXWindowsClipboard&
+    createClipboard()
+    {
+        CXWindowsClipboard* clipboard;
+        clipboard = new CXWindowsClipboard(m_display, m_window, 0);
+        clipboard->open(0); // needed to empty the clipboard
+        clipboard->empty(); // needed to own the clipboard
+        return *clipboard;
+    }
+
+    Display* m_display;
+    Window m_window;
+};
+
+TEST_F(CXWindowsClipboardTests, empty_openCalled_returnsTrue)
+{
+    CXWindowsClipboard clipboard = createClipboard();
+    
+    bool actual = clipboard.empty();
+    
+    EXPECT_EQ(true, actual);
+}
+
+TEST_F(CXWindowsClipboardTests, empty_singleFormat_hasReturnsFalse)
+{
+    CXWindowsClipboard clipboard = createClipboard();
+    clipboard.add(CXWindowsClipboard::kText, "barrier rocks!");
+    
+    clipboard.empty();
+    
+    bool actual = clipboard.has(CXWindowsClipboard::kText);
+    EXPECT_FALSE(actual);
+}
+
+TEST_F(CXWindowsClipboardTests, add_newValue_valueWasStored)
+{
+    CXWindowsClipboard clipboard = createClipboard();
+    
+    clipboard.add(IClipboard::kText, "barrier rocks!");
+    
+    String actual = clipboard.get(IClipboard::kText);
+    EXPECT_EQ("barrier rocks!", actual);
+}
+
+TEST_F(CXWindowsClipboardTests, add_replaceValue_valueWasReplaced)
+{
+    CXWindowsClipboard clipboard = createClipboard();
+    
+    clipboard.add(IClipboard::kText, "barrier rocks!");
+    clipboard.add(IClipboard::kText, "maxivista sucks"); // haha, just kidding.
+    
+    String actual = clipboard.get(IClipboard::kText);
+    EXPECT_EQ("maxivista sucks", actual);
+}
+
+TEST_F(CXWindowsClipboardTests, close_isOpen_noErrors)
+{
+    CXWindowsClipboard clipboard = createClipboard();
+    
+    // clipboard opened in createClipboard()
+    clipboard.close();
+    
+    // can't assert anything
+}
+
+TEST_F(CXWindowsClipboardTests, has_withFormatAdded_returnsTrue)
+{
+    CXWindowsClipboard clipboard = createClipboard();
+    clipboard.add(IClipboard::kText, "barrier rocks!");
+    
+    bool actual = clipboard.has(IClipboard::kText);
+    
+    EXPECT_EQ(true, actual);
+}
+
+TEST_F(CXWindowsClipboardTests, has_withNoFormats_returnsFalse)
+{
+    CXWindowsClipboard clipboard = createClipboard();
+    
+    bool actual = clipboard.has(IClipboard::kText);
+    
+    EXPECT_FALSE(actual);
+}
+
+TEST_F(CXWindowsClipboardTests, get_withNoFormats_returnsEmpty)
+{
+    CXWindowsClipboard clipboard = createClipboard();
+    
+    String actual = clipboard.get(IClipboard::kText);
+    
+    EXPECT_EQ("", actual);
+}
+
+TEST_F(CXWindowsClipboardTests, get_withFormatAdded_returnsExpected)
+{
+    CXWindowsClipboard clipboard = createClipboard();
+    clipboard.add(IClipboard::kText, "barrier rocks!");
+    
+    String actual = clipboard.get(IClipboard::kText);
+    
+    EXPECT_EQ("barrier rocks!", actual);
+}
+
+#endif
diff --git a/src/test/integtests/platform/XWindowsKeyStateTests.cpp b/src/test/integtests/platform/XWindowsKeyStateTests.cpp
new file mode 100644
index 0000000..ea8ce44
--- /dev/null
+++ b/src/test/integtests/platform/XWindowsKeyStateTests.cpp
@@ -0,0 +1,246 @@
+/*
+ * barrier -- mouse and keyboard sharing utility
+ * Copyright (C) 2012-2016 Symless Ltd.
+ * Copyright (C) 2011 Nick Bolton
+ *
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file LICENSE that should have accompanied this file.
+ *
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define TEST_ENV
+
+#include "test/mock/barrier/MockKeyMap.h"
+#include "test/mock/barrier/MockEventQueue.h"
+#include "platform/XWindowsKeyState.h"
+#include "base/Log.h"
+
+#define XK_LATIN1
+#define XK_MISCELLANY
+#include <X11/keysymdef.h>
+
+#if HAVE_XKB_EXTENSION
+#    include <X11/XKBlib.h>
+#endif
+
+#include "test/global/gtest.h"
+#include "test/global/gmock.h"
+#include <errno.h>
+
+class XWindowsKeyStateTests : public ::testing::Test
+{
+protected:
+    XWindowsKeyStateTests() :
+        m_display(NULL)
+    {
+    }
+
+    ~XWindowsKeyStateTests()
+    {
+        if (m_display != NULL) {
+            LOG((CLOG_DEBUG "closing display"));
+            XCloseDisplay(m_display);
+        }
+    }
+
+    virtual void
+    SetUp()
+    {
+        // open the display only once for the entire test suite
+        if (this->m_display == NULL) {
+            LOG((CLOG_DEBUG "opening display"));
+            this->m_display = XOpenDisplay(NULL);
+
+            ASSERT_TRUE(this->m_display != NULL)
+                << "unable to open display: " << errno;
+        }
+    }
+
+    virtual void
+    TearDown()
+    {
+    }
+
+    Display* m_display;
+};
+
+TEST_F(XWindowsKeyStateTests, setActiveGroup_pollAndSet_groupIsZero)
+{
+    MockKeyMap keyMap;
+    MockEventQueue eventQueue;
+    XWindowsKeyState keyState(
+        m_display, true, &eventQueue, keyMap);
+
+    keyState.setActiveGroup(XWindowsKeyState::kGroupPollAndSet);
+
+    ASSERT_EQ(0, keyState.group());
+}
+
+TEST_F(XWindowsKeyStateTests, setActiveGroup_poll_groupIsNotSet)
+{
+    MockKeyMap keyMap;
+    MockEventQueue eventQueue;
+    XWindowsKeyState keyState(
+        m_display, true, &eventQueue, keyMap);
+
+    keyState.setActiveGroup(XWindowsKeyState::kGroupPoll);
+
+    ASSERT_LE(-1, keyState.group());
+}
+
+TEST_F(XWindowsKeyStateTests, setActiveGroup_customGroup_groupWasSet)
+{
+    MockKeyMap keyMap;
+    MockEventQueue eventQueue;
+    XWindowsKeyState keyState(
+        m_display, true, &eventQueue, keyMap);
+
+    keyState.setActiveGroup(1);
+
+    ASSERT_EQ(1, keyState.group());
+}
+
+TEST_F(XWindowsKeyStateTests, mapModifiersFromX_zeroState_zeroMask)
+{
+    MockKeyMap keyMap;
+    MockEventQueue eventQueue;
+    XWindowsKeyState keyState(
+        m_display, true, &eventQueue, keyMap);
+
+    int mask = keyState.mapModifiersFromX(0);
+
+    ASSERT_EQ(0, mask);
+}
+
+TEST_F(XWindowsKeyStateTests, mapModifiersToX_zeroMask_resultIsTrue)
+{
+    MockKeyMap keyMap;
+    MockEventQueue eventQueue;
+    XWindowsKeyState keyState(
+        m_display, true, &eventQueue, keyMap);
+
+    unsigned int modifiers = 0;
+    bool result = keyState.mapModifiersToX(0, modifiers);
+
+    ASSERT_TRUE(result);
+}
+
+TEST_F(XWindowsKeyStateTests, fakeCtrlAltDel_default_returnsFalse)
+{
+    MockKeyMap keyMap;
+    MockEventQueue eventQueue;
+    XWindowsKeyState keyState(
+        m_display, true, &eventQueue, keyMap);
+
+    bool result = keyState.fakeCtrlAltDel();
+
+    ASSERT_FALSE(result);
+}
+
+TEST_F(XWindowsKeyStateTests, pollActiveModifiers_defaultState_returnsZero)
+{
+    MockKeyMap keyMap;
+    MockEventQueue eventQueue;
+    XWindowsKeyState keyState(
+        m_display, true, &eventQueue, keyMap);
+
+    KeyModifierMask actual = keyState.pollActiveModifiers();
+
+    ASSERT_EQ(0, actual);
+}
+
+#if 0 // TODO: fix, causes sigsegv
+TEST_F(XWindowsKeyStateTests, pollActiveModifiers_shiftKeyDownThenUp_masksAreCorrect)
+{
+    MockKeyMap keyMap;
+    MockEventQueue eventQueue;
+    XWindowsKeyState keyState(
+        m_display, true, &eventQueue, keyMap);
+
+    // set mock modifier mapping
+    std::fill(keyState.modifierFromX().begin(), keyState.modifierFromX().end(), 0);
+    keyState.modifierFromX()[ShiftMapIndex] = KeyModifierShift;
+
+    KeyCode key = XKeysymToKeycode(m_display, XK_Shift_L);
+
+    // fake shift key down (without using barrier)
+    XTestFakeKeyEvent(m_display, key, true, CurrentTime);
+
+    // function under test (1st call)
+    KeyModifierMask modDown = keyState.pollActiveModifiers();
+
+    // fake shift key up (without using barrier)
+    XTestFakeKeyEvent(m_display, key, false, CurrentTime);
+
+    // function under test (2nd call)
+    KeyModifierMask modUp = keyState.pollActiveModifiers();
+
+    EXPECT_TRUE((modDown & KeyModifierShift) == KeyModifierShift)
+        << "shift key not in mask - key was not pressed";
+
+    EXPECT_TRUE((modUp & KeyModifierShift) == 0)
+        << "shift key still in mask - make sure no keys are being held down";
+}
+#endif
+
+TEST_F(XWindowsKeyStateTests, pollActiveGroup_defaultState_returnsZero)
+{
+    MockKeyMap keyMap;
+    MockEventQueue eventQueue;
+    XWindowsKeyState keyState(
+        m_display, true, &eventQueue, keyMap);
+
+    SInt32 actual = keyState.pollActiveGroup();
+
+    ASSERT_EQ(0, actual);
+}
+
+TEST_F(XWindowsKeyStateTests, pollActiveGroup_positiveGroup_returnsGroup)
+{
+    MockKeyMap keyMap;
+    MockEventQueue eventQueue;
+    XWindowsKeyState keyState(
+        m_display, true, &eventQueue, keyMap);
+
+    keyState.group(3);
+
+    SInt32 actual = keyState.pollActiveGroup();
+
+    ASSERT_EQ(3, actual);
+}
+
+TEST_F(XWindowsKeyStateTests, pollActiveGroup_xkb_areEqual)
+{
+#if HAVE_XKB_EXTENSION
+    MockKeyMap keyMap;
+    MockEventQueue eventQueue;
+    XWindowsKeyState keyState(
+        m_display, true, &eventQueue, keyMap);
+
+    // reset the group
+    keyState.group(-1);
+
+    XkbStateRec state;
+
+    // compare pollActiveGroup() with XkbGetState()
+    if (XkbGetState(m_display, XkbUseCoreKbd, &state) == Success) {
+        SInt32 actual = keyState.pollActiveGroup();
+
+        ASSERT_EQ(state.group, actual);
+    }
+    else {
+        FAIL() << "XkbGetState() returned error " << errno;
+    }
+#else
+    SUCCEED() << "Xkb extension not installed";
+#endif
+}
+
diff --git a/src/test/integtests/platform/XWindowsScreenSaverTests.cpp b/src/test/integtests/platform/XWindowsScreenSaverTests.cpp
new file mode 100644
index 0000000..c6a2710
--- /dev/null
+++ b/src/test/integtests/platform/XWindowsScreenSaverTests.cpp
@@ -0,0 +1,48 @@
+/*
+ * barrier -- mouse and keyboard sharing utility
+ * Copyright (C) 2012-2016 Symless Ltd.
+ * Copyright (C) 2011 Nick Bolton
+ *
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file LICENSE that should have accompanied this file.
+ *
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// TODO: fix tests
+#if 0
+
+#include "test/mock/barrier/MockEventQueue.h"
+#include "platform/XWindowsScreenSaver.h"
+
+#include "test/global/gtest.h"
+#include <X11/Xlib.h>
+
+using ::testing::_;
+
+// TODO: not working on build machine for some reason
+TEST(CXWindowsScreenSaverTests, activate_defaultScreen_todo)
+{
+    Display* display = XOpenDisplay(":0.0");
+    Window window = DefaultRootWindow(display);
+    MockEventQueue eventQueue;
+    EXPECT_CALL(eventQueue, removeHandler(_, _)).Times(1);
+    CXWindowsScreenSaver screenSaver(
+        display, window, NULL, &eventQueue);
+
+    screenSaver.activate();
+
+    bool isActive = screenSaver.isActive();
+
+    screenSaver.deactivate();
+
+    ASSERT_EQ(true, isActive);
+}
+#endif
diff --git a/src/test/integtests/platform/XWindowsScreenTests.cpp b/src/test/integtests/platform/XWindowsScreenTests.cpp
new file mode 100644
index 0000000..b74599c
--- /dev/null
+++ b/src/test/integtests/platform/XWindowsScreenTests.cpp
@@ -0,0 +1,41 @@
+/*
+ * barrier -- mouse and keyboard sharing utility
+ * Copyright (C) 2012-2016 Symless Ltd.
+ * Copyright (C) 2011 Nick Bolton
+ *
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file LICENSE that should have accompanied this file.
+ *
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "test/mock/barrier/MockEventQueue.h"
+#include "platform/XWindowsScreen.h"
+
+#include "test/global/gtest.h"
+
+using ::testing::_;
+
+TEST(CXWindowsScreenTests, fakeMouseMove_nonPrimary_getCursorPosValuesCorrect)
+{
+    MockEventQueue eventQueue;
+    EXPECT_CALL(eventQueue, adoptHandler(_, _, _)).Times(2);
+    EXPECT_CALL(eventQueue, adoptBuffer(_)).Times(2);
+    EXPECT_CALL(eventQueue, removeHandler(_, _)).Times(2);
+    XWindowsScreen screen(
+        ":0.0", false, false, 0, &eventQueue);
+
+    screen.fakeMouseMove(10, 20);
+
+    int x, y;
+    screen.getCursorPos(x, y);
+    ASSERT_EQ(10, x);
+    ASSERT_EQ(20, y);
+}