mirror of
https://github.com/debauchee/barrier.git
synced 2026-05-11 00:58:14 +08:00
removed trunk; please commit to (and build patches against) release branches instead.
This commit is contained in:
Nick Bolton
@@ -1,26 +0,0 @@
|
||||
# synergy -- mouse and keyboard sharing utility
|
||||
# Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
|
||||
#
|
||||
# This package is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# found in the file COPYING that should have accompanied this file.
|
||||
#
|
||||
# This package is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
include_directories(
|
||||
../../tools/gtest-1.6.0
|
||||
../../tools/gtest-1.6.0/include
|
||||
../../tools/gmock-1.6.0
|
||||
../../tools/gmock-1.6.0/include)
|
||||
|
||||
add_library(gtest STATIC ../../tools/gtest-1.6.0/src/gtest-all.cc)
|
||||
add_library(gmock STATIC ../../tools/gmock-1.6.0/src/gmock-all.cc)
|
||||
|
||||
add_subdirectory(integtests)
|
||||
add_subdirectory(unittests)
|
||||
@@ -1,71 +0,0 @@
|
||||
# synergy -- mouse and keyboard sharing utility
|
||||
# Copyright (C) 2009 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
|
||||
#
|
||||
# This package is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# found in the file COPYING that should have accompanied this file.
|
||||
#
|
||||
# This package is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
set(src
|
||||
Main.cpp
|
||||
)
|
||||
|
||||
if (WIN32)
|
||||
|
||||
# windows
|
||||
list(APPEND src
|
||||
platform/CMSWindowsClipboardTests.cpp
|
||||
platform/CMSWindowsKeyStateTests.cpp
|
||||
)
|
||||
|
||||
elseif (APPLE)
|
||||
|
||||
# mac
|
||||
list(APPEND src
|
||||
platform/COSXClipboardTests.cpp
|
||||
platform/COSXKeyStateTests.cpp
|
||||
)
|
||||
|
||||
elseif (UNIX)
|
||||
|
||||
# unix/linux
|
||||
list(APPEND src
|
||||
platform/CXWindowsClipboardTests.cpp
|
||||
platform/CXWindowsKeyStateTests.cpp
|
||||
)
|
||||
|
||||
endif()
|
||||
|
||||
set(inc
|
||||
../../lib/arch
|
||||
../../lib/base
|
||||
../../lib/client
|
||||
../../lib/common
|
||||
../../lib/io
|
||||
../../lib/mt
|
||||
../../lib/net
|
||||
../../lib/platform
|
||||
../../lib/synergy
|
||||
../../../tools/gtest-1.6.0/include
|
||||
../../../tools/gmock-1.6.0/include
|
||||
../unittests
|
||||
../unittests/synergy
|
||||
)
|
||||
|
||||
if (UNIX)
|
||||
list(APPEND inc
|
||||
../../..
|
||||
)
|
||||
endif()
|
||||
|
||||
include_directories(${inc})
|
||||
add_executable(integtests ${src})
|
||||
target_link_libraries(integtests
|
||||
arch base client common io mt net platform server synergy gtest gmock ${libs})
|
||||
@@ -1,72 +0,0 @@
|
||||
/*
|
||||
* synergy -- mouse and keyboard sharing utility
|
||||
* Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
|
||||
*
|
||||
* This package is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* found in the file COPYING that should have accompanied this file.
|
||||
*
|
||||
* This package is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <iostream>
|
||||
#include <gtest/gtest.h>
|
||||
#include "CArch.h"
|
||||
#include "CLog.h"
|
||||
|
||||
#if SYSAPI_WIN32
|
||||
#include "CArchMiscWindows.h"
|
||||
#endif
|
||||
|
||||
#if SYSAPI_UNIX
|
||||
#include <fstream>
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
#include <signal.h>
|
||||
#define LOCK_FILE "/tmp/integtests.lock"
|
||||
#endif
|
||||
|
||||
#define ERROR_ALREADY_RUNNING 1
|
||||
|
||||
using namespace std;
|
||||
|
||||
#if SYSAPI_UNIX
|
||||
|
||||
void
|
||||
signalHandler(int signal);
|
||||
|
||||
void
|
||||
removeLock();
|
||||
|
||||
#endif
|
||||
|
||||
int
|
||||
main(int argc, char **argv)
|
||||
{
|
||||
#if SYSAPI_WIN32
|
||||
if (CArchMiscWindows::isWindows95Family())
|
||||
{
|
||||
std::cerr << "Windows 95 family not supported." << std::endl;
|
||||
return 1;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if SYSAPI_WIN32
|
||||
// record window instance for tray icon, etc
|
||||
CArchMiscWindows::setInstanceWin32(GetModuleHandle(NULL));
|
||||
#endif
|
||||
|
||||
CArch arch;
|
||||
|
||||
CLOG->setFilter(kDEBUG2);
|
||||
|
||||
testing::InitGoogleTest(&argc, argv);
|
||||
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
@@ -1,227 +0,0 @@
|
||||
/*
|
||||
* synergy -- mouse and keyboard sharing utility
|
||||
* Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
|
||||
*
|
||||
* This package is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* found in the file COPYING that should have accompanied this file.
|
||||
*
|
||||
* This package is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include <gmock/gmock.h>
|
||||
#include "CMSWindowsClipboard.h"
|
||||
#include "IMSWindowsClipboardFacade.h"
|
||||
|
||||
class CMSWindowsClipboardTests : public ::testing::Test
|
||||
{
|
||||
protected:
|
||||
virtual void SetUp()
|
||||
{
|
||||
emptyClipboard();
|
||||
}
|
||||
|
||||
virtual void TearDown()
|
||||
{
|
||||
emptyClipboard();
|
||||
}
|
||||
|
||||
private:
|
||||
void emptyClipboard()
|
||||
{
|
||||
CMSWindowsClipboard clipboard(NULL);
|
||||
clipboard.open(0);
|
||||
clipboard.empty();
|
||||
}
|
||||
};
|
||||
|
||||
class MockFacade : public IMSWindowsClipboardFacade
|
||||
{
|
||||
public:
|
||||
MOCK_METHOD2(write, void(HANDLE, UINT));
|
||||
};
|
||||
|
||||
TEST_F(CMSWindowsClipboardTests, emptyUnowned_openCalled_returnsTrue)
|
||||
{
|
||||
CMSWindowsClipboard clipboard(NULL);
|
||||
clipboard.open(0);
|
||||
|
||||
bool actual = clipboard.emptyUnowned();
|
||||
|
||||
EXPECT_EQ(true, actual);
|
||||
}
|
||||
|
||||
TEST_F(CMSWindowsClipboardTests, empty_openCalled_returnsTrue)
|
||||
{
|
||||
CMSWindowsClipboard clipboard(NULL);
|
||||
clipboard.open(0);
|
||||
|
||||
bool actual = clipboard.empty();
|
||||
|
||||
EXPECT_EQ(true, actual);
|
||||
}
|
||||
|
||||
TEST_F(CMSWindowsClipboardTests, empty_singleFormat_hasReturnsFalse)
|
||||
{
|
||||
CMSWindowsClipboard clipboard(NULL);
|
||||
clipboard.open(0);
|
||||
clipboard.add(CMSWindowsClipboard::kText, "synergy rocks!");
|
||||
|
||||
clipboard.empty();
|
||||
|
||||
bool actual = clipboard.has(CMSWindowsClipboard::kText);
|
||||
EXPECT_EQ(false, actual);
|
||||
}
|
||||
|
||||
TEST_F(CMSWindowsClipboardTests, add_newValue_valueWasStored)
|
||||
{
|
||||
CMSWindowsClipboard clipboard(NULL);
|
||||
clipboard.open(0);
|
||||
|
||||
clipboard.add(IClipboard::kText, "synergy rocks!");
|
||||
|
||||
CString actual = clipboard.get(IClipboard::kText);
|
||||
EXPECT_EQ("synergy rocks!", actual);
|
||||
}
|
||||
|
||||
TEST_F(CMSWindowsClipboardTests, add_newValue_writeWasCalled)
|
||||
{
|
||||
MockFacade facade;
|
||||
EXPECT_CALL(facade, write(testing::_, testing::_));
|
||||
|
||||
CMSWindowsClipboard clipboard(NULL);
|
||||
clipboard.setFacade(facade);
|
||||
clipboard.open(0);
|
||||
|
||||
clipboard.add(IClipboard::kText, "synergy rocks!");
|
||||
}
|
||||
|
||||
TEST_F(CMSWindowsClipboardTests, add_replaceValue_valueWasReplaced)
|
||||
{
|
||||
CMSWindowsClipboard clipboard(NULL);
|
||||
clipboard.open(0);
|
||||
|
||||
clipboard.add(IClipboard::kText, "synergy rocks!");
|
||||
clipboard.add(IClipboard::kText, "maxivista sucks"); // haha, just kidding.
|
||||
|
||||
CString actual = clipboard.get(IClipboard::kText);
|
||||
EXPECT_EQ("maxivista sucks", actual);
|
||||
}
|
||||
|
||||
TEST_F(CMSWindowsClipboardTests, open_timeIsZero_returnsTrue)
|
||||
{
|
||||
CMSWindowsClipboard clipboard(NULL);
|
||||
|
||||
bool actual = clipboard.open(0);
|
||||
|
||||
EXPECT_EQ(true, actual);
|
||||
}
|
||||
|
||||
TEST_F(CMSWindowsClipboardTests, open_timeIsOne_returnsTrue)
|
||||
{
|
||||
CMSWindowsClipboard clipboard(NULL);
|
||||
|
||||
bool actual = clipboard.open(1);
|
||||
|
||||
EXPECT_EQ(true, actual);
|
||||
}
|
||||
|
||||
TEST_F(CMSWindowsClipboardTests, close_isOpen_noErrors)
|
||||
{
|
||||
CMSWindowsClipboard clipboard(NULL);
|
||||
clipboard.open(0);
|
||||
|
||||
clipboard.close();
|
||||
|
||||
// can't assert anything
|
||||
}
|
||||
|
||||
// looks like this test may fail intermittently:
|
||||
// * http://buildbot.synergy-foss.org:8000/builders/trunk-win32/builds/246/steps/shell_3/logs/stdio
|
||||
/*TEST_F(CMSWindowsClipboardTests, getTime_openWithNoEmpty_returnsOne)
|
||||
{
|
||||
CMSWindowsClipboard clipboard(NULL);
|
||||
clipboard.open(1);
|
||||
|
||||
CMSWindowsClipboard::Time actual = clipboard.getTime();
|
||||
|
||||
// this behavior is different to that of CClipboard which only
|
||||
// returns the value passed into open(t) after empty() is called.
|
||||
EXPECT_EQ(1, actual);
|
||||
}*/
|
||||
|
||||
// this also fails intermittently:
|
||||
// http://buildbot.synergy-foss.org:8000/builders/trunk-win32/builds/266/steps/shell_3/logs/stdio
|
||||
/*TEST_F(CMSWindowsClipboardTests, getTime_openAndEmpty_returnsOne)
|
||||
{
|
||||
CMSWindowsClipboard clipboard(NULL);
|
||||
clipboard.open(1);
|
||||
clipboard.empty();
|
||||
|
||||
CMSWindowsClipboard::Time actual = clipboard.getTime();
|
||||
|
||||
EXPECT_EQ(1, actual);
|
||||
}*/
|
||||
|
||||
TEST_F(CMSWindowsClipboardTests, has_withFormatAdded_returnsTrue)
|
||||
{
|
||||
CMSWindowsClipboard clipboard(NULL);
|
||||
clipboard.open(0);
|
||||
clipboard.empty();
|
||||
clipboard.add(IClipboard::kText, "synergy rocks!");
|
||||
|
||||
bool actual = clipboard.has(IClipboard::kText);
|
||||
|
||||
EXPECT_EQ(true, actual);
|
||||
}
|
||||
|
||||
TEST_F(CMSWindowsClipboardTests, has_withNoFormats_returnsFalse)
|
||||
{
|
||||
CMSWindowsClipboard clipboard(NULL);
|
||||
clipboard.open(0);
|
||||
clipboard.empty();
|
||||
|
||||
bool actual = clipboard.has(IClipboard::kText);
|
||||
|
||||
EXPECT_EQ(false, actual);
|
||||
}
|
||||
|
||||
TEST_F(CMSWindowsClipboardTests, get_withNoFormats_returnsEmpty)
|
||||
{
|
||||
CMSWindowsClipboard clipboard(NULL);
|
||||
clipboard.open(0);
|
||||
clipboard.empty();
|
||||
|
||||
CString actual = clipboard.get(IClipboard::kText);
|
||||
|
||||
EXPECT_EQ("", actual);
|
||||
}
|
||||
|
||||
TEST_F(CMSWindowsClipboardTests, get_withFormatAdded_returnsExpected)
|
||||
{
|
||||
CMSWindowsClipboard clipboard(NULL);
|
||||
clipboard.open(0);
|
||||
clipboard.empty();
|
||||
clipboard.add(IClipboard::kText, "synergy rocks!");
|
||||
|
||||
CString actual = clipboard.get(IClipboard::kText);
|
||||
|
||||
EXPECT_EQ("synergy rocks!", actual);
|
||||
}
|
||||
|
||||
TEST_F(CMSWindowsClipboardTests, isOwnedBySynergy_defaultState_noError)
|
||||
{
|
||||
CMSWindowsClipboard clipboard(NULL);
|
||||
clipboard.open(0);
|
||||
|
||||
bool actual = clipboard.isOwnedBySynergy();
|
||||
|
||||
EXPECT_EQ(true, actual);
|
||||
}
|
||||
@@ -1,134 +0,0 @@
|
||||
/*
|
||||
* synergy -- mouse and keyboard sharing utility
|
||||
* Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
|
||||
*
|
||||
* This package is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* found in the file COPYING that should have accompanied this file.
|
||||
*
|
||||
* This package is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include <gmock/gmock.h>
|
||||
#include "CMSWindowsKeyState.h"
|
||||
#include "CMSWindowsDesks.h"
|
||||
#include "CMSWindowsScreen.h"
|
||||
#include "CMSWindowsScreenSaver.h"
|
||||
#include "TMethodJob.h"
|
||||
#include "CMockEventQueue.h"
|
||||
#include "CMockKeyMap.h"
|
||||
|
||||
// wParam = flags, HIBYTE(lParam) = virtual key, LOBYTE(lParam) = scan code
|
||||
#define SYNERGY_MSG_FAKE_KEY SYNERGY_HOOK_LAST_MSG + 4
|
||||
|
||||
using ::testing::_;
|
||||
using ::testing::NiceMock;
|
||||
|
||||
class CMSWindowsKeyStateTests : public ::testing::Test
|
||||
{
|
||||
protected:
|
||||
virtual void SetUp()
|
||||
{
|
||||
// load synrgyhk.dll
|
||||
m_hookLibrary = m_hookLibraryLoader.openHookLibrary("synrgyhk");
|
||||
m_screensaver = new CMSWindowsScreenSaver();
|
||||
m_desks = new CMSWindowsDesks(
|
||||
true, false, m_hookLibrary, m_screensaver,
|
||||
new TMethodJob<CMSWindowsKeyStateTests>(
|
||||
this, &CMSWindowsKeyStateTests::updateKeysCB));
|
||||
}
|
||||
|
||||
virtual void TearDown()
|
||||
{
|
||||
delete m_screensaver;
|
||||
delete m_desks;
|
||||
}
|
||||
|
||||
CMSWindowsDesks* getDesks() const
|
||||
{
|
||||
return m_desks;
|
||||
}
|
||||
|
||||
void* getEventTarget() const
|
||||
{
|
||||
return const_cast<CMSWindowsKeyStateTests*>(this);
|
||||
}
|
||||
|
||||
private:
|
||||
void updateKeysCB(void*) { }
|
||||
HINSTANCE m_hookLibrary;
|
||||
IScreenSaver* m_screensaver;
|
||||
CMSWindowsDesks* m_desks;
|
||||
CMSWindowsHookLibraryLoader m_hookLibraryLoader;
|
||||
};
|
||||
|
||||
TEST_F(CMSWindowsKeyStateTests, disable_nonWin95OS_eventQueueNotUsed)
|
||||
{
|
||||
NiceMock<CMockEventQueue> eventQueue;
|
||||
CMockKeyMap keyMap;
|
||||
CMSWindowsKeyState keyState(getDesks(), getEventTarget(), eventQueue, keyMap);
|
||||
|
||||
// in anything above win95-family, event handler should not be called.
|
||||
EXPECT_CALL(eventQueue, removeHandler(_, _)).Times(0);
|
||||
|
||||
keyState.disable();
|
||||
}
|
||||
|
||||
TEST_F(CMSWindowsKeyStateTests, testAutoRepeat_noRepeatAndButtonIsZero_resultIsTrue)
|
||||
{
|
||||
NiceMock<CMockEventQueue> eventQueue;
|
||||
CMockKeyMap keyMap;
|
||||
CMSWindowsKeyState keyState(getDesks(), getEventTarget(), eventQueue, keyMap);
|
||||
keyState.setLastDown(1);
|
||||
|
||||
bool actual = keyState.testAutoRepeat(true, false, 1);
|
||||
|
||||
ASSERT_TRUE(actual);
|
||||
}
|
||||
|
||||
TEST_F(CMSWindowsKeyStateTests, testAutoRepeat_pressFalse_lastDownIsZero)
|
||||
{
|
||||
NiceMock<CMockEventQueue> eventQueue;
|
||||
CMockKeyMap keyMap;
|
||||
CMSWindowsKeyState keyState(getDesks(), getEventTarget(), eventQueue, keyMap);
|
||||
keyState.setLastDown(1);
|
||||
|
||||
keyState.testAutoRepeat(false, false, 1);
|
||||
|
||||
ASSERT_EQ(0, keyState.getLastDown());
|
||||
}
|
||||
|
||||
TEST_F(CMSWindowsKeyStateTests, saveModifiers_noModifiers_savedModifiers0)
|
||||
{
|
||||
NiceMock<CMockEventQueue> eventQueue;
|
||||
CMockKeyMap keyMap;
|
||||
CMSWindowsKeyState keyState(getDesks(), getEventTarget(), eventQueue, keyMap);
|
||||
|
||||
keyState.saveModifiers();
|
||||
|
||||
ASSERT_EQ(0, keyState.getSavedModifiers());
|
||||
}
|
||||
|
||||
/*
|
||||
// TODO: fix Assertion failed: s_instance != NULL,
|
||||
// file ..\..\..\..\src\lib\base\IEventQueue.cpp, line 37
|
||||
TEST_F(CMSWindowsKeyStateTests, saveModifiers_shiftKeyDown_savedModifiers4)
|
||||
{
|
||||
NiceMock<CMockEventQueue> eventQueue;
|
||||
CMockKeyMap keyMap;
|
||||
CMSWindowsKeyState keyState(getDesks(), getEventTarget(), eventQueue, keyMap);
|
||||
getDesks()->enable();
|
||||
getDesks()->fakeKeyEvent(1, 1, true, false);
|
||||
|
||||
keyState.saveModifiers();
|
||||
|
||||
ASSERT_EQ(1, keyState.getSavedModifiers());
|
||||
}
|
||||
*/
|
||||
@@ -1,162 +0,0 @@
|
||||
/*
|
||||
* synergy -- mouse and keyboard sharing utility
|
||||
* Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
|
||||
*
|
||||
* This package is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* found in the file COPYING that should have accompanied this file.
|
||||
*
|
||||
* This package is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <iostream>
|
||||
#include <gtest/gtest.h>
|
||||
#include "COSXClipboard.h"
|
||||
|
||||
TEST(COSXClipboardTests, empty_openCalled_returnsTrue)
|
||||
{
|
||||
COSXClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
|
||||
bool actual = clipboard.empty();
|
||||
|
||||
EXPECT_EQ(true, actual);
|
||||
}
|
||||
|
||||
TEST(COSXClipboardTests, empty_singleFormat_hasReturnsFalse)
|
||||
{
|
||||
COSXClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
clipboard.add(COSXClipboard::kText, "synergy rocks!");
|
||||
|
||||
clipboard.empty();
|
||||
|
||||
bool actual = clipboard.has(COSXClipboard::kText);
|
||||
EXPECT_EQ(false, actual);
|
||||
}
|
||||
|
||||
TEST(COSXClipboardTests, add_newValue_valueWasStored)
|
||||
{
|
||||
COSXClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
|
||||
clipboard.add(IClipboard::kText, "synergy rocks!");
|
||||
|
||||
CString actual = clipboard.get(IClipboard::kText);
|
||||
EXPECT_EQ("synergy rocks!", actual);
|
||||
}
|
||||
|
||||
TEST(COSXClipboardTests, add_replaceValue_valueWasReplaced)
|
||||
{
|
||||
COSXClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
|
||||
clipboard.add(IClipboard::kText, "synergy rocks!");
|
||||
clipboard.add(IClipboard::kText, "maxivista sucks"); // haha, just kidding.
|
||||
|
||||
CString actual = clipboard.get(IClipboard::kText);
|
||||
EXPECT_EQ("maxivista sucks", actual);
|
||||
}
|
||||
|
||||
TEST(COSXClipboardTests, open_timeIsZero_returnsTrue)
|
||||
{
|
||||
COSXClipboard clipboard;
|
||||
|
||||
bool actual = clipboard.open(0);
|
||||
|
||||
EXPECT_EQ(true, actual);
|
||||
}
|
||||
|
||||
TEST(COSXClipboardTests, open_timeIsOne_returnsTrue)
|
||||
{
|
||||
COSXClipboard clipboard;
|
||||
|
||||
bool actual = clipboard.open(1);
|
||||
|
||||
EXPECT_EQ(true, actual);
|
||||
}
|
||||
|
||||
TEST(COSXClipboardTests, close_isOpen_noErrors)
|
||||
{
|
||||
COSXClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
|
||||
clipboard.close();
|
||||
|
||||
// can't assert anything
|
||||
}
|
||||
|
||||
TEST(COSXClipboardTests, getTime_openWithNoEmpty_returnsOne)
|
||||
{
|
||||
COSXClipboard clipboard;
|
||||
clipboard.open(1);
|
||||
|
||||
COSXClipboard::Time actual = clipboard.getTime();
|
||||
|
||||
// this behavior is different to that of CClipboard which only
|
||||
// returns the value passed into open(t) after empty() is called.
|
||||
EXPECT_EQ((UInt32)1, actual);
|
||||
}
|
||||
|
||||
TEST(COSXClipboardTests, getTime_openAndEmpty_returnsOne)
|
||||
{
|
||||
COSXClipboard clipboard;
|
||||
clipboard.open(1);
|
||||
clipboard.empty();
|
||||
|
||||
COSXClipboard::Time actual = clipboard.getTime();
|
||||
|
||||
EXPECT_EQ((UInt32)1, actual);
|
||||
}
|
||||
|
||||
TEST(COSXClipboardTests, has_withFormatAdded_returnsTrue)
|
||||
{
|
||||
COSXClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
clipboard.empty();
|
||||
clipboard.add(IClipboard::kText, "synergy rocks!");
|
||||
|
||||
bool actual = clipboard.has(IClipboard::kText);
|
||||
|
||||
EXPECT_EQ(true, actual);
|
||||
}
|
||||
|
||||
TEST(COSXClipboardTests, has_withNoFormats_returnsFalse)
|
||||
{
|
||||
COSXClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
clipboard.empty();
|
||||
|
||||
bool actual = clipboard.has(IClipboard::kText);
|
||||
|
||||
EXPECT_EQ(false, actual);
|
||||
}
|
||||
|
||||
TEST(COSXClipboardTests, get_withNoFormats_returnsEmpty)
|
||||
{
|
||||
COSXClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
clipboard.empty();
|
||||
|
||||
CString actual = clipboard.get(IClipboard::kText);
|
||||
|
||||
EXPECT_EQ("", actual);
|
||||
}
|
||||
|
||||
TEST(COSXClipboardTests, get_withFormatAdded_returnsExpected)
|
||||
{
|
||||
COSXClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
clipboard.empty();
|
||||
clipboard.add(IClipboard::kText, "synergy rocks!");
|
||||
|
||||
CString actual = clipboard.get(IClipboard::kText);
|
||||
|
||||
EXPECT_EQ("synergy rocks!", actual);
|
||||
}
|
||||
@@ -1,98 +0,0 @@
|
||||
/*
|
||||
* synergy -- mouse and keyboard sharing utility
|
||||
* Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
|
||||
*
|
||||
* This package is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* found in the file COPYING that should have accompanied this file.
|
||||
*
|
||||
* This package is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include <gmock/gmock.h>
|
||||
|
||||
#include "COSXKeyState.h"
|
||||
#include "CMockKeyMap.h"
|
||||
#include "CMockEventQueue.h"
|
||||
|
||||
CGKeyCode escKeyCode = 53;
|
||||
CGKeyCode shiftKeyCode = 56;
|
||||
CGKeyCode controlKeyCode = 59;
|
||||
|
||||
// TODO: make pollActiveModifiers tests work reliably.
|
||||
/*
|
||||
TEST(COSXKeyStateTests, pollActiveModifiers_shiftKeyDownThenUp_masksAreCorrect)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
COSXKeyState keyState((IEventQueue&)keyMap, (CKeyMap&)eventQueue);
|
||||
|
||||
// fake shift key down (without using synergy). this is a bit weird;
|
||||
// looks like you need to create a shift down event *and* set the
|
||||
// shift modifier.
|
||||
CGEventRef shiftDown = CGEventCreateKeyboardEvent(NULL, shiftKeyCode, true);
|
||||
CGEventSetFlags(shiftDown, kCGEventFlagMaskShift);
|
||||
CGEventPost(kCGHIDEventTap, shiftDown);
|
||||
CFRelease(shiftDown);
|
||||
|
||||
// function under test (1st call)
|
||||
KeyModifierMask downMask = keyState.pollActiveModifiers();
|
||||
|
||||
// fake shift key up (without using synergy). also as weird as the
|
||||
// shift down; use a non-shift key down and reset the pressed modifiers.
|
||||
CGEventRef shiftUp = CGEventCreateKeyboardEvent(NULL, escKeyCode, true);
|
||||
CGEventSetFlags(shiftUp, 0);
|
||||
CGEventPost(kCGHIDEventTap, shiftUp);
|
||||
CFRelease(shiftUp);
|
||||
|
||||
// function under test (2nd call)
|
||||
KeyModifierMask upMask = keyState.pollActiveModifiers();
|
||||
|
||||
EXPECT_TRUE((downMask & KeyModifierShift) == KeyModifierShift)
|
||||
<< "shift key not in mask (" << downMask << ") - key was not pressed";
|
||||
|
||||
EXPECT_TRUE((upMask & KeyModifierShift) == 0)
|
||||
<< "shift key still in mask (" << upMask << ") - make sure no keys are being held down";
|
||||
}
|
||||
|
||||
TEST(COSXKeyStateTests, pollActiveModifiers_controlKeyDownThenUp_masksAreCorrect)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
COSXKeyState keyState((IEventQueue&)keyMap, (CKeyMap&)eventQueue);
|
||||
|
||||
// fake control key down (without using synergy). this is a bit weird;
|
||||
// looks like you need to create a shift down event *and* set the
|
||||
// shift modifier.
|
||||
CGEventRef controlDown = CGEventCreateKeyboardEvent(NULL, controlKeyCode, true);
|
||||
CGEventSetFlags(controlDown, kCGEventFlagMaskControl);
|
||||
CGEventPost(kCGHIDEventTap, controlDown);
|
||||
CFRelease(controlDown);
|
||||
|
||||
// function under test (1st call)
|
||||
KeyModifierMask downMask = keyState.pollActiveModifiers();
|
||||
|
||||
// fake control key up (without using synergy). also as weird as the
|
||||
// shift down; use a non-shift key down and reset the pressed modifiers.
|
||||
CGEventRef controlUp = CGEventCreateKeyboardEvent(NULL, escKeyCode, true);
|
||||
CGEventSetFlags(controlUp, 0);
|
||||
CGEventPost(kCGHIDEventTap, controlUp);
|
||||
CFRelease(controlUp);
|
||||
|
||||
// function under test (2nd call)
|
||||
KeyModifierMask upMask = keyState.pollActiveModifiers();
|
||||
|
||||
EXPECT_TRUE((downMask & KeyModifierControl) == KeyModifierControl)
|
||||
<< "control key not in mask (" << downMask << ") - key was not pressed";
|
||||
|
||||
EXPECT_TRUE((upMask & KeyModifierControl) == 0)
|
||||
<< "control key still in mask (" << upMask << ") - make sure no keys are being held down";
|
||||
}
|
||||
*/
|
||||
@@ -1,150 +0,0 @@
|
||||
/*
|
||||
* synergy -- mouse and keyboard sharing utility
|
||||
* Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
|
||||
*
|
||||
* This package is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* found in the file COPYING that should have accompanied this file.
|
||||
*
|
||||
* This package is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <iostream>
|
||||
#include <gtest/gtest.h>
|
||||
#include "CXWindowsClipboard.h"
|
||||
|
||||
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, "synergy 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, "synergy rocks!");
|
||||
|
||||
CString actual = clipboard.get(IClipboard::kText);
|
||||
EXPECT_EQ("synergy rocks!", actual);
|
||||
}
|
||||
|
||||
TEST_F(CXWindowsClipboardTests, add_replaceValue_valueWasReplaced)
|
||||
{
|
||||
CXWindowsClipboard clipboard = createClipboard();
|
||||
|
||||
clipboard.add(IClipboard::kText, "synergy rocks!");
|
||||
clipboard.add(IClipboard::kText, "maxivista sucks"); // haha, just kidding.
|
||||
|
||||
CString actual = clipboard.get(IClipboard::kText);
|
||||
EXPECT_EQ("maxivista sucks", actual);
|
||||
}
|
||||
|
||||
TEST_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, "synergy 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();
|
||||
|
||||
CString actual = clipboard.get(IClipboard::kText);
|
||||
|
||||
EXPECT_EQ("", actual);
|
||||
}
|
||||
|
||||
TEST_F(CXWindowsClipboardTests, get_withFormatAdded_returnsExpected)
|
||||
{
|
||||
CXWindowsClipboard clipboard = createClipboard();
|
||||
clipboard.add(IClipboard::kText, "synergy rocks!");
|
||||
|
||||
CString actual = clipboard.get(IClipboard::kText);
|
||||
|
||||
EXPECT_EQ("synergy rocks!", actual);
|
||||
}
|
||||
@@ -1,245 +0,0 @@
|
||||
/*
|
||||
* synergy -- mouse and keyboard sharing utility
|
||||
* Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
|
||||
*
|
||||
* This package is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* found in the file COPYING that should have accompanied this file.
|
||||
*
|
||||
* This package is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include <gmock/gmock.h>
|
||||
|
||||
#define TEST_ENV
|
||||
#include "Global.h"
|
||||
|
||||
#include "CMockKeyMap.h"
|
||||
#include "CMockEventQueue.h"
|
||||
#include "CXWindowsKeyState.h"
|
||||
#include "CLog.h"
|
||||
#include <errno.h>
|
||||
|
||||
#define XK_LATIN1
|
||||
#define XK_MISCELLANY
|
||||
#include "X11/keysymdef.h"
|
||||
|
||||
#if HAVE_XKB_EXTENSION
|
||||
# include <X11/XKBlib.h>
|
||||
#endif
|
||||
|
||||
class CXWindowsKeyStateTests : public ::testing::Test
|
||||
{
|
||||
protected:
|
||||
CXWindowsKeyStateTests() :
|
||||
m_display(NULL)
|
||||
{
|
||||
}
|
||||
|
||||
~CXWindowsKeyStateTests()
|
||||
{
|
||||
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(CXWindowsKeyStateTests, setActiveGroup_pollAndSet_groupIsZero)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CXWindowsKeyState keyState(
|
||||
m_display, true, (IEventQueue&)keyMap, (CKeyMap&)eventQueue);
|
||||
|
||||
keyState.setActiveGroup(CXWindowsKeyState::kGroupPollAndSet);
|
||||
|
||||
ASSERT_EQ(0, keyState.m_group);
|
||||
}
|
||||
|
||||
TEST_F(CXWindowsKeyStateTests, setActiveGroup_poll_groupIsNotSet)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CXWindowsKeyState keyState(
|
||||
m_display, true, (IEventQueue&)keyMap, (CKeyMap&)eventQueue);
|
||||
|
||||
keyState.setActiveGroup(CXWindowsKeyState::kGroupPoll);
|
||||
|
||||
ASSERT_LE(-1, keyState.m_group);
|
||||
}
|
||||
|
||||
TEST_F(CXWindowsKeyStateTests, setActiveGroup_customGroup_groupWasSet)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CXWindowsKeyState keyState(
|
||||
m_display, true, (IEventQueue&)keyMap, (CKeyMap&)eventQueue);
|
||||
|
||||
keyState.setActiveGroup(1);
|
||||
|
||||
ASSERT_EQ(1, keyState.m_group);
|
||||
}
|
||||
|
||||
TEST_F(CXWindowsKeyStateTests, mapModifiersFromX_zeroState_zeroMask)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CXWindowsKeyState keyState(
|
||||
m_display, true, (IEventQueue&)keyMap, (CKeyMap&)eventQueue);
|
||||
|
||||
int mask = keyState.mapModifiersFromX(0);
|
||||
|
||||
ASSERT_EQ(0, mask);
|
||||
}
|
||||
|
||||
TEST_F(CXWindowsKeyStateTests, mapModifiersToX_zeroMask_resultIsTrue)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CXWindowsKeyState keyState(
|
||||
m_display, true, (IEventQueue&)keyMap, (CKeyMap&)eventQueue);
|
||||
|
||||
unsigned int modifiers = 0;
|
||||
bool result = keyState.mapModifiersToX(0, modifiers);
|
||||
|
||||
ASSERT_TRUE(result);
|
||||
}
|
||||
|
||||
TEST_F(CXWindowsKeyStateTests, fakeCtrlAltDel_default_returnsFalse)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CXWindowsKeyState keyState(
|
||||
m_display, true, (IEventQueue&)keyMap, (CKeyMap&)eventQueue);
|
||||
|
||||
bool result = keyState.fakeCtrlAltDel();
|
||||
|
||||
ASSERT_FALSE(result);
|
||||
}
|
||||
|
||||
TEST_F(CXWindowsKeyStateTests, pollActiveModifiers_defaultState_returnsZero)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CXWindowsKeyState keyState(
|
||||
m_display, true, (IEventQueue&)keyMap, (CKeyMap&)eventQueue);
|
||||
|
||||
KeyModifierMask actual = keyState.pollActiveModifiers();
|
||||
|
||||
ASSERT_EQ(0, actual);
|
||||
}
|
||||
|
||||
TEST_F(CXWindowsKeyStateTests, pollActiveModifiers_shiftKeyDownThenUp_masksAreCorrect)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CXWindowsKeyState keyState(
|
||||
m_display, true, (IEventQueue&)keyMap, (CKeyMap&)eventQueue);
|
||||
|
||||
// set mock modifier mapping
|
||||
std::fill(
|
||||
keyState.m_modifierFromX.begin(), keyState.m_modifierFromX.end(), 0);
|
||||
keyState.m_modifierFromX[ShiftMapIndex] = KeyModifierShift;
|
||||
|
||||
KeyCode key = XKeysymToKeycode(m_display, XK_Shift_L);
|
||||
|
||||
// fake shift key down (without using synergy)
|
||||
XTestFakeKeyEvent(m_display, key, true, CurrentTime);
|
||||
|
||||
// function under test (1st call)
|
||||
KeyModifierMask modDown = keyState.pollActiveModifiers();
|
||||
|
||||
// fake shift key up (without using synergy)
|
||||
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";
|
||||
}
|
||||
|
||||
TEST_F(CXWindowsKeyStateTests, pollActiveGroup_defaultState_returnsZero)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CXWindowsKeyState keyState(
|
||||
m_display, true, (IEventQueue&)keyMap, (CKeyMap&)eventQueue);
|
||||
|
||||
SInt32 actual = keyState.pollActiveGroup();
|
||||
|
||||
ASSERT_EQ(0, actual);
|
||||
}
|
||||
|
||||
TEST_F(CXWindowsKeyStateTests, pollActiveGroup_positiveGroup_returnsGroup)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CXWindowsKeyState keyState(
|
||||
m_display, true, (IEventQueue&)keyMap, (CKeyMap&)eventQueue);
|
||||
|
||||
keyState.m_group = 3;
|
||||
|
||||
SInt32 actual = keyState.pollActiveGroup();
|
||||
|
||||
ASSERT_EQ(3, actual);
|
||||
}
|
||||
|
||||
TEST_F(CXWindowsKeyStateTests, pollActiveGroup_xkb_areEqual)
|
||||
{
|
||||
#if HAVE_XKB_EXTENSION
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CXWindowsKeyState keyState(
|
||||
m_display, true, (IEventQueue&)keyMap, (CKeyMap&)eventQueue);
|
||||
|
||||
// reset the group
|
||||
keyState.m_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
|
||||
}
|
||||
|
||||
@@ -1,52 +0,0 @@
|
||||
# synergy -- mouse and keyboard sharing utility
|
||||
# Copyright (C) 2009 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
|
||||
#
|
||||
# This package is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU General Public License
|
||||
# found in the file COPYING that should have accompanied this file.
|
||||
#
|
||||
# This package is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
|
||||
set(h
|
||||
synergy/CKeyStateTests.h
|
||||
synergy/CMockEventQueue.h
|
||||
synergy/CMockKeyMap.h
|
||||
)
|
||||
|
||||
set(src
|
||||
${h}
|
||||
Main.cpp
|
||||
synergy/CClipboardTests.cpp
|
||||
synergy/CKeyStateTests.cpp
|
||||
)
|
||||
|
||||
set(inc
|
||||
../../lib/arch
|
||||
../../lib/base
|
||||
../../lib/client
|
||||
../../lib/common
|
||||
../../lib/io
|
||||
../../lib/mt
|
||||
../../lib/net
|
||||
../../lib/platform
|
||||
../../lib/synergy
|
||||
../../../tools/gtest-1.6.0/include
|
||||
../../../tools/gmock-1.6.0/include
|
||||
)
|
||||
|
||||
if (UNIX)
|
||||
list(APPEND inc
|
||||
../../..
|
||||
)
|
||||
endif()
|
||||
|
||||
include_directories(${inc})
|
||||
add_executable(unittests ${src})
|
||||
target_link_libraries(unittests
|
||||
arch base client common io mt net platform server synergy gtest gmock ${libs})
|
||||
@@ -1,41 +0,0 @@
|
||||
/*
|
||||
* synergy -- mouse and keyboard sharing utility
|
||||
* Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
|
||||
*
|
||||
* This package is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* found in the file COPYING that should have accompanied this file.
|
||||
*
|
||||
* This package is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include "CArch.h"
|
||||
#include "CLog.h"
|
||||
|
||||
#if SYSAPI_WIN32
|
||||
#include "CArchMiscWindows.h"
|
||||
#endif
|
||||
|
||||
int
|
||||
main(int argc, char **argv)
|
||||
{
|
||||
#if SYSAPI_WIN32
|
||||
// HACK: shouldn't be needed, but logging fails without this.
|
||||
CArchMiscWindows::setInstanceWin32(GetModuleHandle(NULL));
|
||||
#endif
|
||||
|
||||
CArch arch;
|
||||
|
||||
CLOG->setFilter(kDEBUG2);
|
||||
|
||||
testing::InitGoogleTest(&argc, argv);
|
||||
|
||||
return RUN_ALL_TESTS();
|
||||
}
|
||||
@@ -1,402 +0,0 @@
|
||||
/*
|
||||
* synergy -- mouse and keyboard sharing utility
|
||||
* Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
|
||||
*
|
||||
* This package is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* found in the file COPYING that should have accompanied this file.
|
||||
*
|
||||
* This package is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include "CClipboard.h"
|
||||
|
||||
TEST(CClipboardTests, empty_openCalled_returnsTrue)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
|
||||
bool actual = clipboard.empty();
|
||||
|
||||
EXPECT_EQ(true, actual);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, empty_singleFormat_hasReturnsFalse)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
clipboard.add(CClipboard::kText, "synergy rocks!");
|
||||
|
||||
clipboard.empty();
|
||||
|
||||
bool actual = clipboard.has(CClipboard::kText);
|
||||
EXPECT_FALSE(actual);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, add_newValue_valueWasStored)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
|
||||
clipboard.add(IClipboard::kText, "synergy rocks!");
|
||||
|
||||
CString actual = clipboard.get(IClipboard::kText);
|
||||
EXPECT_EQ("synergy rocks!", actual);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, add_replaceValue_valueWasReplaced)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
|
||||
clipboard.add(IClipboard::kText, "synergy rocks!");
|
||||
clipboard.add(IClipboard::kText, "maxivista sucks"); // haha, just kidding.
|
||||
|
||||
CString actual = clipboard.get(IClipboard::kText);
|
||||
EXPECT_EQ("maxivista sucks", actual);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, open_timeIsZero_returnsTrue)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
|
||||
bool actual = clipboard.open(0);
|
||||
|
||||
EXPECT_EQ(true, actual);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, open_timeIsOne_returnsTrue)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
|
||||
bool actual = clipboard.open(1);
|
||||
|
||||
EXPECT_EQ(true, actual);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, close_isOpen_noErrors)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
|
||||
clipboard.close();
|
||||
|
||||
// can't assert anything
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, getTime_openWithNoEmpty_returnsZero)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
clipboard.open(1);
|
||||
|
||||
CClipboard::Time actual = clipboard.getTime();
|
||||
|
||||
EXPECT_EQ(0, actual);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, getTime_openAndEmpty_returnsOne)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
clipboard.open(1);
|
||||
clipboard.empty();
|
||||
|
||||
CClipboard::Time actual = clipboard.getTime();
|
||||
|
||||
EXPECT_EQ(1, actual);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, has_withFormatAdded_returnsTrue)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
clipboard.add(IClipboard::kText, "synergy rocks!");
|
||||
|
||||
bool actual = clipboard.has(IClipboard::kText);
|
||||
|
||||
EXPECT_EQ(true, actual);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, has_withNoFormats_returnsFalse)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
|
||||
bool actual = clipboard.has(IClipboard::kText);
|
||||
|
||||
EXPECT_FALSE(actual);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, get_withNoFormats_returnsEmpty)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
|
||||
CString actual = clipboard.get(IClipboard::kText);
|
||||
|
||||
EXPECT_EQ("", actual);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, get_withFormatAdded_returnsExpected)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
clipboard.add(IClipboard::kText, "synergy rocks!");
|
||||
|
||||
CString actual = clipboard.get(IClipboard::kText);
|
||||
|
||||
EXPECT_EQ("synergy rocks!", actual);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, marshall_addNotCalled_firstCharIsZero)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
|
||||
CString actual = clipboard.marshall();
|
||||
|
||||
// seems to return "\0\0\0\0" but EXPECT_EQ can't assert this,
|
||||
// so instead, just assert that first char is '\0'.
|
||||
EXPECT_EQ(0, (int)actual[0]);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, marshall_withTextAdded_typeCharIsText)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
clipboard.add(IClipboard::kText, "synergy rocks!");
|
||||
clipboard.close();
|
||||
|
||||
CString actual = clipboard.marshall();
|
||||
|
||||
// string contains other data, but 8th char should be kText.
|
||||
EXPECT_EQ(IClipboard::kText, (int)actual[7]);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, marshall_withTextAdded_lastSizeCharIs14)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
clipboard.add(IClipboard::kText, "synergy rocks!"); // 14 chars
|
||||
clipboard.close();
|
||||
|
||||
CString actual = clipboard.marshall();
|
||||
|
||||
EXPECT_EQ(14, (int)actual[11]);
|
||||
}
|
||||
|
||||
// TODO: there's some integer -> char encoding going on here. i find it
|
||||
// hard to believe that the clipboard is the only thing doing this. maybe
|
||||
// we should refactor this stuff out of the clipboard.
|
||||
TEST(CClipboardTests, marshall_withTextSize285_sizeCharsValid)
|
||||
{
|
||||
// 285 chars
|
||||
CString data;
|
||||
data.append("Synergy is Free and Open Source Software that lets you ");
|
||||
data.append("easily share your mouse and keyboard between multiple ");
|
||||
data.append("computers, where each computer has it's own display. No ");
|
||||
data.append("special hardware is required, all you need is a local area ");
|
||||
data.append("network. Synergy is supported on Windows, Mac OS X and Linux.");
|
||||
|
||||
CClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
clipboard.add(IClipboard::kText, data);
|
||||
clipboard.close();
|
||||
|
||||
CString actual = clipboard.marshall();
|
||||
|
||||
// 4 asserts here, but that's ok because we're really just asserting 1
|
||||
// thing. the 32-bit size value is split into 4 chars. if the size is 285
|
||||
// (29 more than the 8-bit max size), the last char "rolls over" to 29
|
||||
// (this is caused by a bit-wise & on 0xff and 8-bit truncation). each
|
||||
// char before the last stores a bit-shifted version of the number, each
|
||||
// 1 more power than the last, which is done by bit-shifting [0] by 24,
|
||||
// [1] by 16, [2] by 8 ([3] is not bit-shifted).
|
||||
EXPECT_EQ(0, actual[8]); // 285 >> 24 = 285 / (256^3) = 0
|
||||
EXPECT_EQ(0, actual[9]); // 285 >> 16 = 285 / (256^2) = 0
|
||||
EXPECT_EQ(1, actual[10]); // 285 >> 8 = 285 / (256^1) = 1(.11328125)
|
||||
EXPECT_EQ(29, actual[11]); // 285 - 256 = 29
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, marshall_withHtmlAdded_typeCharIsHtml)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
clipboard.add(IClipboard::kHTML, "html sucks");
|
||||
clipboard.close();
|
||||
|
||||
CString actual = clipboard.marshall();
|
||||
|
||||
// string contains other data, but 8th char should be kHTML.
|
||||
EXPECT_EQ(IClipboard::kHTML, (int)actual[7]);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, marshall_withHtmlAndText_has2Formats)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
clipboard.add(IClipboard::kText, "synergy rocks");
|
||||
clipboard.add(IClipboard::kHTML, "html sucks");
|
||||
clipboard.close();
|
||||
|
||||
CString actual = clipboard.marshall();
|
||||
|
||||
// the number of formats is stored inside the first 4 chars.
|
||||
// the writeUInt32 function right-aligns numbers in 4 chars,
|
||||
// so if you right align 2, it will be "\0\0\0\2" in a string.
|
||||
// we assert that the char at the 4th index is 2 (the number of
|
||||
// formats that we've added).
|
||||
EXPECT_EQ(2, (int)actual[3]);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, marshall_withTextAdded_endsWithAdded)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
clipboard.open(0);
|
||||
clipboard.add(IClipboard::kText, "synergy rocks!");
|
||||
clipboard.close();
|
||||
|
||||
CString actual = clipboard.marshall();
|
||||
|
||||
// string contains other data, but should end in the string we added.
|
||||
EXPECT_EQ("synergy rocks!", actual.substr(12));
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, unmarshall_emptyData_hasTextIsFalse)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
|
||||
CString data;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)0; // 0 formats added
|
||||
|
||||
clipboard.unmarshall(data, 0);
|
||||
|
||||
clipboard.open(0);
|
||||
bool actual = clipboard.has(IClipboard::kText);
|
||||
EXPECT_FALSE(actual);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, unmarshall_withTextSize285_getTextIsValid)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
|
||||
// 285 chars
|
||||
CString text;
|
||||
text.append("Synergy is Free and Open Source Software that lets you ");
|
||||
text.append("easily share your mouse and keyboard between multiple ");
|
||||
text.append("computers, where each computer has it's own display. No ");
|
||||
text.append("special hardware is required, all you need is a local area ");
|
||||
text.append("network. Synergy is supported on Windows, Mac OS X and Linux.");
|
||||
|
||||
CString data;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)1; // 1 format added
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)IClipboard::kText;
|
||||
data += (char)0; // 285 >> 24 = 285 / (256^3) = 0
|
||||
data += (char)0; // 285 >> 16 = 285 / (256^2) = 0
|
||||
data += (char)1; // 285 >> 8 = 285 / (256^1) = 1(.11328125)
|
||||
data += (char)29; // 285 - 256 = 29
|
||||
data += text;
|
||||
|
||||
clipboard.unmarshall(data, 0);
|
||||
|
||||
clipboard.open(0);
|
||||
CString actual = clipboard.get(IClipboard::kText);
|
||||
EXPECT_EQ(text, actual);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, unmarshall_withTextAndHtml_getTextIsValid)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
CString data;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)2; // 2 formats added
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)IClipboard::kText;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)14;
|
||||
data += "synergy rocks!";
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)IClipboard::kHTML;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)10;
|
||||
data += "html sucks";
|
||||
|
||||
clipboard.unmarshall(data, 0);
|
||||
|
||||
clipboard.open(0);
|
||||
CString actual = clipboard.get(IClipboard::kText);
|
||||
EXPECT_EQ("synergy rocks!", actual);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, unmarshall_withTextAndHtml_getHtmlIsValid)
|
||||
{
|
||||
CClipboard clipboard;
|
||||
CString data;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)2; // 2 formats added
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)IClipboard::kText;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)14;
|
||||
data += "synergy rocks!";
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)IClipboard::kHTML;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)0;
|
||||
data += (char)10;
|
||||
data += "html sucks";
|
||||
|
||||
clipboard.unmarshall(data, 0);
|
||||
|
||||
clipboard.open(0);
|
||||
CString actual = clipboard.get(IClipboard::kHTML);
|
||||
EXPECT_EQ("html sucks", actual);
|
||||
}
|
||||
|
||||
TEST(CClipboardTests, copy_withSingleText_clipboardsAreEqual)
|
||||
{
|
||||
CClipboard clipboard1;
|
||||
clipboard1.open(0);
|
||||
clipboard1.add(CClipboard::kText, "synergy rocks!");
|
||||
clipboard1.close();
|
||||
|
||||
CClipboard clipboard2;
|
||||
CClipboard::copy(&clipboard2, &clipboard1);
|
||||
|
||||
clipboard2.open(0);
|
||||
CString actual = clipboard2.get(CClipboard::kText);
|
||||
EXPECT_EQ("synergy rocks!", actual);
|
||||
}
|
||||
@@ -1,451 +0,0 @@
|
||||
/*
|
||||
* synergy -- mouse and keyboard sharing utility
|
||||
* Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
|
||||
*
|
||||
* This package is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* found in the file COPYING that should have accompanied this file.
|
||||
*
|
||||
* This package is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <gtest/gtest.h>
|
||||
#include <gmock/gmock.h>
|
||||
#include "CKeyStateTests.h"
|
||||
#include "CMockEventQueue.h"
|
||||
#include "CMockKeyMap.h"
|
||||
|
||||
using ::testing::_;
|
||||
using ::testing::NiceMock;
|
||||
using ::testing::Invoke;
|
||||
using ::testing::Return;
|
||||
using ::testing::SaveArg;
|
||||
|
||||
TEST(CKeyStateTests, onKey_aKeyDown_keyStateOne)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
keyState.onKey(1, true, KeyModifierAlt);
|
||||
|
||||
EXPECT_EQ(1, keyState.getKeyState(1));
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, onKey_aKeyUp_keyStateZero)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
keyState.onKey(1, false, KeyModifierAlt);
|
||||
|
||||
EXPECT_EQ(0, keyState.getKeyState(1));
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, onKey_invalidKey_keyStateZero)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
keyState.onKey(0, true, KeyModifierAlt);
|
||||
|
||||
EXPECT_EQ(0, keyState.getKeyState(0));
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, sendKeyEvent_halfDuplexAndRepeat_addEventNotCalled)
|
||||
{
|
||||
NiceMock<CMockKeyMap> keyMap;
|
||||
NiceMock<CMockEventQueue> eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
ON_CALL(keyMap, isHalfDuplex(_, _)).WillByDefault(Return(true));
|
||||
|
||||
EXPECT_CALL(eventQueue, addEvent(_)).Times(0);
|
||||
|
||||
keyState.sendKeyEvent(NULL, false, true, kKeyCapsLock, 0, 0, 0);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, sendKeyEvent_halfDuplex_addEventCalledTwice)
|
||||
{
|
||||
NiceMock<CMockKeyMap> keyMap;
|
||||
NiceMock<CMockEventQueue> eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
ON_CALL(keyMap, isHalfDuplex(_, _)).WillByDefault(Return(true));
|
||||
|
||||
EXPECT_CALL(eventQueue, addEvent(_)).Times(2);
|
||||
|
||||
keyState.sendKeyEvent(NULL, false, false, kKeyCapsLock, 0, 0, 0);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, sendKeyEvent_keyRepeat_addEventCalledOnce)
|
||||
{
|
||||
NiceMock<CMockKeyMap> keyMap;
|
||||
NiceMock<CMockEventQueue> eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
EXPECT_CALL(eventQueue, addEvent(_)).Times(1);
|
||||
|
||||
keyState.sendKeyEvent(NULL, false, true, 1, 0, 0, 0);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, sendKeyEvent_keyDown_addEventCalledOnce)
|
||||
{
|
||||
NiceMock<CMockKeyMap> keyMap;
|
||||
NiceMock<CMockEventQueue> eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
EXPECT_CALL(eventQueue, addEvent(_)).Times(1);
|
||||
|
||||
keyState.sendKeyEvent(NULL, true, false, 1, 0, 0, 0);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, sendKeyEvent_keyUp_addEventCalledOnce)
|
||||
{
|
||||
NiceMock<CMockKeyMap> keyMap;
|
||||
NiceMock<CMockEventQueue> eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
EXPECT_CALL(eventQueue, addEvent(_)).Times(1);
|
||||
|
||||
keyState.sendKeyEvent(NULL, false, false, 1, 0, 0, 0);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, updateKeyMap_mockKeyMap_keyMapGotMock)
|
||||
{
|
||||
NiceMock<CMockKeyMap> keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
// key map member gets a new key map via swap()
|
||||
EXPECT_CALL(keyMap, swap(_));
|
||||
|
||||
keyState.updateKeyMap();
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, updateKeyState_pollInsertsSingleKey_keyIsDown)
|
||||
{
|
||||
NiceMock<CMockKeyMap> keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
ON_CALL(keyState, pollPressedKeys(_)).WillByDefault(Invoke(stubPollPressedKeys));
|
||||
|
||||
keyState.updateKeyState();
|
||||
|
||||
bool actual = keyState.isKeyDown(1);
|
||||
ASSERT_TRUE(actual);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, updateKeyState_pollDoesNothing_keyNotSet)
|
||||
{
|
||||
NiceMock<CMockKeyMap> keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
keyState.updateKeyState();
|
||||
|
||||
bool actual = keyState.isKeyDown(1);
|
||||
ASSERT_FALSE(actual);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, updateKeyState_activeModifiers_maskSet)
|
||||
{
|
||||
NiceMock<CMockKeyMap> keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
ON_CALL(keyState, pollActiveModifiers()).WillByDefault(Return(KeyModifierAlt));
|
||||
|
||||
keyState.updateKeyState();
|
||||
|
||||
KeyModifierMask actual = keyState.getActiveModifiers();
|
||||
ASSERT_EQ(KeyModifierAlt, actual);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, updateKeyState_activeModifiers_maskNotSet)
|
||||
{
|
||||
NiceMock<CMockKeyMap> keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
keyState.updateKeyState();
|
||||
|
||||
KeyModifierMask actual = keyState.getActiveModifiers();
|
||||
ASSERT_EQ(0, actual);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, updateKeyState_activeModifiers_keyMapGotModifers)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
ON_CALL(keyState, pollActiveModifiers()).WillByDefault(Return(1));
|
||||
ON_CALL(keyMap, foreachKey(_, _)).WillByDefault(Invoke(assertMaskIsOne));
|
||||
|
||||
// key map gets new modifiers via foreachKey()
|
||||
EXPECT_CALL(keyMap, foreachKey(_, _));
|
||||
|
||||
keyState.updateKeyState();
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, setHalfDuplexMask_capsLock_halfDuplexCapsLockAdded)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
EXPECT_CALL(keyMap, addHalfDuplexModifier(kKeyCapsLock));
|
||||
|
||||
keyState.setHalfDuplexMask(KeyModifierCapsLock);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, setHalfDuplexMask_numLock_halfDuplexNumLockAdded)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
EXPECT_CALL(keyMap, addHalfDuplexModifier(kKeyNumLock));
|
||||
|
||||
keyState.setHalfDuplexMask(KeyModifierNumLock);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, setHalfDuplexMask_scrollLock_halfDuplexScollLockAdded)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
EXPECT_CALL(keyMap, addHalfDuplexModifier(kKeyScrollLock));
|
||||
|
||||
keyState.setHalfDuplexMask(KeyModifierScrollLock);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, fakeKeyDown_serverKeyAlreadyDown_fakeKeyCalledTwice)
|
||||
{
|
||||
NiceMock<CMockKeyMap> keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
s_stubKeyItem.m_client = 0;
|
||||
s_stubKeyItem.m_button = 1;
|
||||
ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Invoke(stubMapKey));
|
||||
|
||||
// 2 calls to fakeKeyDown should still call fakeKey, even though
|
||||
// repeated keys are handled differently.
|
||||
EXPECT_CALL(keyState, fakeKey(_)).Times(2);
|
||||
|
||||
// call twice to simulate server key already down (a misreported autorepeat).
|
||||
keyState.fakeKeyDown(1, 0, 0);
|
||||
keyState.fakeKeyDown(1, 0, 0);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, fakeKeyDown_isIgnoredKey_fakeKeyNotCalled)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
EXPECT_CALL(keyState, fakeKey(_)).Times(0);
|
||||
|
||||
keyState.fakeKeyDown(kKeyCapsLock, 0, 0);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, fakeKeyDown_mapReturnsKeystrokes_fakeKeyCalled)
|
||||
{
|
||||
NiceMock<CMockKeyMap> keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
s_stubKeyItem.m_button = 0;
|
||||
s_stubKeyItem.m_client = 0;
|
||||
ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Invoke(stubMapKey));
|
||||
|
||||
EXPECT_CALL(keyState, fakeKey(_)).Times(1);
|
||||
|
||||
keyState.fakeKeyDown(1, 0, 0);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, fakeKeyRepeat_invalidKey_returnsFalse)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
bool actual = keyState.fakeKeyRepeat(0, 0, 0, 0);
|
||||
|
||||
ASSERT_FALSE(actual);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, fakeKeyRepeat_nullKey_returnsFalse)
|
||||
{
|
||||
NiceMock<CMockKeyMap> keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
// set the key to down (we need to make mapKey return a valid key to do this).
|
||||
CKeyMap::KeyItem keyItem;
|
||||
keyItem.m_client = 0;
|
||||
keyItem.m_button = 1;
|
||||
ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Return(&keyItem));
|
||||
keyState.fakeKeyDown(1, 0, 0);
|
||||
|
||||
// change mapKey to return NULL so that fakeKeyRepeat exits early.
|
||||
CKeyMap::KeyItem* nullKeyItem = NULL;
|
||||
ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Return(nullKeyItem));
|
||||
|
||||
bool actual = keyState.fakeKeyRepeat(1, 0, 0, 0);
|
||||
|
||||
ASSERT_FALSE(actual);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, fakeKeyRepeat_invalidButton_returnsFalse)
|
||||
{
|
||||
NiceMock<CMockKeyMap> keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
// set the key to down (we need to make mapKey return a valid key to do this).
|
||||
CKeyMap::KeyItem keyItem;
|
||||
keyItem.m_client = 0;
|
||||
keyItem.m_button = 1; // set to 1 to make fakeKeyDown work.
|
||||
ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Return(&keyItem));
|
||||
keyState.fakeKeyDown(1, 0, 0);
|
||||
|
||||
// change button to 0 so that fakeKeyRepeat will return early.
|
||||
keyItem.m_button = 0;
|
||||
ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Return(&keyItem));
|
||||
|
||||
bool actual = keyState.fakeKeyRepeat(1, 0, 0, 0);
|
||||
|
||||
ASSERT_FALSE(actual);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, fakeKeyRepeat_validKey_returnsTrue)
|
||||
{
|
||||
NiceMock<CMockKeyMap> keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
s_stubKeyItem.m_client = 0;
|
||||
s_stubKeystroke.m_type = CKeyMap::Keystroke::kButton;
|
||||
s_stubKeystroke.m_data.m_button.m_button = 2;
|
||||
|
||||
// set the button to 1 for fakeKeyDown call
|
||||
s_stubKeyItem.m_button = 1;
|
||||
ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Invoke(stubMapKey));
|
||||
keyState.fakeKeyDown(1, 0, 0);
|
||||
|
||||
// change the button to 2
|
||||
s_stubKeyItem.m_button = 2;
|
||||
ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Invoke(stubMapKey));
|
||||
|
||||
bool actual = keyState.fakeKeyRepeat(1, 0, 0, 0);
|
||||
|
||||
ASSERT_TRUE(actual);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, fakeKeyUp_buttonNotDown_returnsFalse)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
bool actual = keyState.fakeKeyUp(0);
|
||||
|
||||
ASSERT_FALSE(actual);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, fakeKeyUp_buttonAlreadyDown_returnsTrue)
|
||||
{
|
||||
NiceMock<CMockKeyMap> keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
// press alt down so we get full coverage.
|
||||
ON_CALL(keyState, pollActiveModifiers()).WillByDefault(Return(KeyModifierAlt));
|
||||
keyState.updateKeyState();
|
||||
|
||||
// press button 1 down.
|
||||
s_stubKeyItem.m_button = 1;
|
||||
ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Invoke(stubMapKey));
|
||||
keyState.fakeKeyDown(1, 0, 1);
|
||||
|
||||
// this takes the button id, which is the 3rd arg of fakeKeyDown
|
||||
bool actual = keyState.fakeKeyUp(1);
|
||||
|
||||
ASSERT_TRUE(actual);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, fakeAllKeysUp_keysWereDown_keysAreUp)
|
||||
{
|
||||
NiceMock<CMockKeyMap> keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
// press button 1 down.
|
||||
s_stubKeyItem.m_button = 1;
|
||||
ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Invoke(stubMapKey));
|
||||
keyState.fakeKeyDown(1, 0, 1);
|
||||
|
||||
// method under test
|
||||
keyState.fakeAllKeysUp();
|
||||
|
||||
bool actual = keyState.isKeyDown(1);
|
||||
ASSERT_FALSE(actual);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, isKeyDown_keyDown_returnsTrue)
|
||||
{
|
||||
NiceMock<CMockKeyMap> keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
// press button 1 down.
|
||||
s_stubKeyItem.m_button = 1;
|
||||
ON_CALL(keyMap, mapKey(_, _, _, _, _, _, _)).WillByDefault(Invoke(stubMapKey));
|
||||
keyState.fakeKeyDown(1, 0, 1);
|
||||
|
||||
// method under test
|
||||
bool actual = keyState.isKeyDown(1);
|
||||
|
||||
ASSERT_TRUE(actual);
|
||||
}
|
||||
|
||||
TEST(CKeyStateTests, isKeyDown_noKeysDown_returnsFalse)
|
||||
{
|
||||
CMockKeyMap keyMap;
|
||||
CMockEventQueue eventQueue;
|
||||
CKeyStateImpl keyState(eventQueue, keyMap);
|
||||
|
||||
// method under test
|
||||
bool actual = keyState.isKeyDown(1);
|
||||
|
||||
ASSERT_FALSE(actual);
|
||||
}
|
||||
|
||||
void
|
||||
stubPollPressedKeys(IKeyState::KeyButtonSet& pressedKeys)
|
||||
{
|
||||
pressedKeys.insert(1);
|
||||
}
|
||||
|
||||
void
|
||||
assertMaskIsOne(ForeachKeyCallback cb, void* userData)
|
||||
{
|
||||
ASSERT_EQ(1, ((CKeyState::CAddActiveModifierContext*)userData)->m_mask);
|
||||
}
|
||||
|
||||
const CKeyMap::KeyItem*
|
||||
stubMapKey(
|
||||
CKeyMap::Keystrokes& keys, KeyID id, SInt32 group,
|
||||
CKeyMap::ModifierToKeys& activeModifiers,
|
||||
KeyModifierMask& currentState,
|
||||
KeyModifierMask desiredMask,
|
||||
bool isAutoRepeat)
|
||||
{
|
||||
keys.push_back(s_stubKeystroke);
|
||||
return &s_stubKeyItem;
|
||||
}
|
||||
@@ -1,73 +0,0 @@
|
||||
/*
|
||||
* synergy -- mouse and keyboard sharing utility
|
||||
* Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
|
||||
*
|
||||
* This package is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* found in the file COPYING that should have accompanied this file.
|
||||
*
|
||||
* This package is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CKEYSTATETESTS_H
|
||||
#define CKEYSTATETESTS_H
|
||||
|
||||
#include "CKeyState.h"
|
||||
#include "gmock/gmock.h"
|
||||
|
||||
class CMockKeyMap;
|
||||
class CMockEventQueue;
|
||||
|
||||
// NOTE: do not mock methods that are not pure virtual. this mock exists only
|
||||
// to provide an implementation of the CKeyState abstract class.
|
||||
class CMockKeyState : public CKeyState
|
||||
{
|
||||
public:
|
||||
CMockKeyState() : CKeyState()
|
||||
{
|
||||
}
|
||||
|
||||
CMockKeyState(const CMockEventQueue& eventQueue, const CMockKeyMap& keyMap) :
|
||||
CKeyState((IEventQueue&)eventQueue, (CKeyMap&)keyMap)
|
||||
{
|
||||
}
|
||||
|
||||
MOCK_CONST_METHOD0(pollActiveGroup, SInt32());
|
||||
MOCK_CONST_METHOD0(pollActiveModifiers, KeyModifierMask());
|
||||
MOCK_METHOD0(fakeCtrlAltDel, bool());
|
||||
MOCK_METHOD1(getKeyMap, void(CKeyMap&));
|
||||
MOCK_METHOD1(fakeKey, void(const Keystroke&));
|
||||
MOCK_CONST_METHOD1(pollPressedKeys, void(KeyButtonSet&));
|
||||
};
|
||||
|
||||
typedef ::testing::NiceMock<CMockKeyState> CKeyStateImpl;
|
||||
|
||||
typedef UInt32 KeyID;
|
||||
|
||||
typedef void (*ForeachKeyCallback)(
|
||||
KeyID, SInt32 group, CKeyMap::KeyItem&, void* userData);
|
||||
|
||||
void
|
||||
stubPollPressedKeys(IKeyState::KeyButtonSet& pressedKeys);
|
||||
|
||||
void
|
||||
assertMaskIsOne(ForeachKeyCallback cb, void* userData);
|
||||
|
||||
const CKeyMap::KeyItem*
|
||||
stubMapKey(
|
||||
CKeyMap::Keystrokes& keys, KeyID id, SInt32 group,
|
||||
CKeyMap::ModifierToKeys& activeModifiers,
|
||||
KeyModifierMask& currentState,
|
||||
KeyModifierMask desiredMask,
|
||||
bool isAutoRepeat);
|
||||
|
||||
CKeyMap::Keystroke s_stubKeystroke(1, false, false);
|
||||
CKeyMap::KeyItem s_stubKeyItem;
|
||||
|
||||
#endif
|
||||
@@ -1,44 +0,0 @@
|
||||
/*
|
||||
* synergy -- mouse and keyboard sharing utility
|
||||
* Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
|
||||
*
|
||||
* This package is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* found in the file COPYING that should have accompanied this file.
|
||||
*
|
||||
* This package is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CMOCKEVENTQUEUE_H
|
||||
#define CMOCKEVENTQUEUE_H
|
||||
|
||||
#include <gmock/gmock.h>
|
||||
#include "IEventQueue.h"
|
||||
|
||||
class CMockEventQueue : public IEventQueue
|
||||
{
|
||||
public:
|
||||
MOCK_METHOD2(newOneShotTimer, CEventQueueTimer*(double, void*));
|
||||
MOCK_METHOD2(newTimer, CEventQueueTimer*(double, void*));
|
||||
MOCK_METHOD2(getEvent, bool(CEvent&, double));
|
||||
MOCK_METHOD1(adoptBuffer, void(IEventQueueBuffer*));
|
||||
MOCK_METHOD2(registerTypeOnce, CEvent::Type(CEvent::Type&, const char*));
|
||||
MOCK_METHOD1(removeHandlers, void(void*));
|
||||
MOCK_METHOD1(registerType, CEvent::Type(const char*));
|
||||
MOCK_CONST_METHOD0(isEmpty, bool());
|
||||
MOCK_METHOD3(adoptHandler, void(CEvent::Type, void*, IEventJob*));
|
||||
MOCK_METHOD1(getTypeName, const char*(CEvent::Type));
|
||||
MOCK_METHOD1(addEvent, void(const CEvent&));
|
||||
MOCK_METHOD2(removeHandler, void(CEvent::Type, void*));
|
||||
MOCK_METHOD1(dispatchEvent, bool(const CEvent&));
|
||||
MOCK_CONST_METHOD2(getHandler, IEventJob*(CEvent::Type, void*));
|
||||
MOCK_METHOD1(deleteTimer, void(CEventQueueTimer*));
|
||||
};
|
||||
|
||||
#endif
|
||||
@@ -1,37 +0,0 @@
|
||||
/*
|
||||
* synergy -- mouse and keyboard sharing utility
|
||||
* Copyright (C) 2011 Chris Schoeneman, Nick Bolton, Sorin Sbarnea
|
||||
*
|
||||
* This package is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* found in the file COPYING that should have accompanied this file.
|
||||
*
|
||||
* This package is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef CMOCKKEYMAP_H
|
||||
#define CMOCKKEYMAP_H
|
||||
|
||||
#include <gmock/gmock.h>
|
||||
#include "CKeyMap.h"
|
||||
|
||||
class CMockKeyMap : public CKeyMap
|
||||
{
|
||||
public:
|
||||
MOCK_METHOD1(swap, void(CKeyMap&));
|
||||
MOCK_METHOD0(finish, void());
|
||||
MOCK_METHOD2(foreachKey, void(ForeachKeyCallback, void*));
|
||||
MOCK_METHOD1(addHalfDuplexModifier, void(KeyID));
|
||||
MOCK_CONST_METHOD2(isHalfDuplex, bool(KeyID, KeyButton));
|
||||
MOCK_CONST_METHOD7(mapKey, const CKeyMap::KeyItem*(
|
||||
Keystrokes&, KeyID, SInt32, ModifierToKeys&, KeyModifierMask&,
|
||||
KeyModifierMask, bool));
|
||||
};
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user