Update googletest (#6878)

* Update googletest to current head

* Use MOCK_METHOD macro instead of MOCK_METHODn ones

MOCK_METHOD supports annotating functions with override and is the
preferred way to define mock methods.

* Use TEST_SUITE instead of TEST_CASE

The former is deprecated, switch to the latter.

* Update changelog

ChangeLog

@@ -5,6 +5,7 @@ Bug fixes:
 - #6872 Check for dns_sd.h only when building GUI
 - #6874 The logo on Windows taskbar is incorrect.
 - #6879 Update macOS installer drive icons
+- #6878 Update googletest library to latest version
 
 Enhancements:
 - #6867 Create only 1 artefact for macOS

ext/googletest

@@ -1 +1 @@
-Subproject commit 2fe3bd994b3189899d93f1d5a881e725e046fdc2
+Subproject commit 18f8200e3079b0e54fa00cb7ac55d4c39dcf6da6

src/test/mock/io/MockStream.h

@@ -28,17 +28,17 @@ class MockStream : public synergy::IStream
 {
 public:
     MockStream() { }
-    MOCK_METHOD0(close, void());
+    MOCK_METHOD(void, close, (), (override));
-    MOCK_METHOD2(read, UInt32(void*, UInt32));
+    MOCK_METHOD(UInt32, read, (void*, UInt32), (override));
-    MOCK_METHOD2(write, void(const void*, UInt32));
+    MOCK_METHOD(void, write, (const void*, UInt32), (override));
-    MOCK_METHOD0(flush, void());
+    MOCK_METHOD(void, flush, (), (override));
-    MOCK_METHOD0(shutdownInput, void());
+    MOCK_METHOD(void, shutdownInput, (), (override));
-    MOCK_METHOD0(shutdownOutput, void());
+    MOCK_METHOD(void, shutdownOutput, (), (override));
-    MOCK_METHOD0(getInputReadyEvent, Event::Type());
+    MOCK_METHOD(Event::Type, getInputReadyEvent, ());
-    MOCK_METHOD0(getOutputErrorEvent, Event::Type());
+    MOCK_METHOD(Event::Type, getOutputErrorEvent, ());
-    MOCK_METHOD0(getInputShutdownEvent, Event::Type());
+    MOCK_METHOD(Event::Type, getInputShutdownEvent, ());
-    MOCK_METHOD0(getOutputShutdownEvent, Event::Type());
+    MOCK_METHOD(Event::Type, getOutputShutdownEvent, ());
-    MOCK_CONST_METHOD0(getEventTarget, void*());
+    MOCK_METHOD(void*, getEventTarget, (), (const, override));
-    MOCK_CONST_METHOD0(isReady, bool());
+    MOCK_METHOD(bool, isReady, (), (const, override));
-    MOCK_CONST_METHOD0(getSize, UInt32());
+    MOCK_METHOD(UInt32, getSize, (), (const, override));
 };

src/test/mock/ipc/MockIpcServer.h

@@ -45,9 +45,9 @@ public:
         }
     }
 
-    MOCK_METHOD0(listen, void());
+    MOCK_METHOD(void, listen, (), (override));
-    MOCK_METHOD2(send, void(const IpcMessage&, EIpcClientType));
+    MOCK_METHOD(void, send, (const IpcMessage&, EIpcClientType), (override));
-    MOCK_CONST_METHOD1(hasClients, bool(EIpcClientType));
+    MOCK_METHOD(bool, hasClients, (EIpcClientType), (const, override));
 
     void delegateToFake() {
         ON_CALL(*this, send(_, _)).WillByDefault(Invoke(this, &MockIpcServer::mockSend));

src/test/mock/server/MockConfig.h

@@ -27,6 +27,6 @@ class MockConfig : public Config
 {
 public:
     MockConfig() : Config() { }
-    MOCK_METHOD0(getInputFilter, InputFilter*());
+    MOCK_METHOD(InputFilter*, getInputFilter, (), (override));
-    MOCK_CONST_METHOD1(isScreen, bool(const String&));
+    MOCK_METHOD(bool, isScreen, (const String&), (const, override));
 };

src/test/mock/server/MockInputFilter.h

@@ -26,5 +26,5 @@
 class MockInputFilter : public InputFilter
 {
 public:
-     MOCK_METHOD1(setPrimaryClient, void(PrimaryClient*));
+     MOCK_METHOD(void, setPrimaryClient, (PrimaryClient*), (override));
 };

src/test/mock/server/MockPrimaryClient.h

@@ -27,15 +27,15 @@
 class MockPrimaryClient : public PrimaryClient
 {
 public:
-    MOCK_CONST_METHOD0(getEventTarget, void*());
+    MOCK_METHOD(void*, getEventTarget, (), (const, override));
-    MOCK_CONST_METHOD2(getCursorPos, void(SInt32&, SInt32&));
+    MOCK_METHOD(void, getCursorPos, (SInt32&, SInt32&), (const, override));
-    MOCK_CONST_METHOD2(setJumpCursorPos, void(SInt32, SInt32));
+    MOCK_METHOD(void, setJumpCursorPos, (SInt32, SInt32), (const));
-    MOCK_METHOD1(reconfigure, void(UInt32));
+    MOCK_METHOD(void, reconfigure, (UInt32), (override));
-    MOCK_METHOD0(resetOptions, void());
+    MOCK_METHOD(void, resetOptions, (), (override));
-    MOCK_METHOD1(setOptions, void(const OptionsList&));
+    MOCK_METHOD(void, setOptions, (const OptionsList&), (override));
-    MOCK_METHOD0(enable, void());
+    MOCK_METHOD(void, enable, (), (override));
-    MOCK_METHOD0(disable, void());
+    MOCK_METHOD(void, disable, (), (override));
-    MOCK_METHOD2(registerHotKey, UInt32(KeyID, KeyModifierMask));
+    MOCK_METHOD(UInt32, registerHotKey, (KeyID, KeyModifierMask), (override));
-    MOCK_CONST_METHOD0(getToggleMask, KeyModifierMask());
+    MOCK_METHOD(KeyModifierMask, getToggleMask, (), (const, override));
-    MOCK_METHOD1(unregisterHotKey, void(UInt32));
+    MOCK_METHOD(void, unregisterHotKey, (UInt32), (override));
 };

src/test/mock/synergy/MockApp.h

@@ -28,17 +28,17 @@ class MockApp : public App
 public:
     MockApp() : App(NULL, NULL, NULL) { }
 
-    MOCK_METHOD0(help, void());
+    MOCK_METHOD(void, help, (), (override));
-    MOCK_METHOD0(loadConfig, void());
+    MOCK_METHOD(void, loadConfig, (), (override));
-    MOCK_METHOD1(loadConfig, bool(const String&));
+    MOCK_METHOD(bool, loadConfig, (const String&), (override));
-    MOCK_CONST_METHOD0(daemonInfo, const char*());
+    MOCK_METHOD(const char*, daemonInfo, (), (const, override));
-    MOCK_CONST_METHOD0(daemonName, const char*());
+    MOCK_METHOD(const char*, daemonName, (), (const, override));
-    MOCK_METHOD2(parseArgs, void(int, const char* const*));
+    MOCK_METHOD(void, parseArgs, (int, const char* const*), (override));
-    MOCK_METHOD0(version, void());
+    MOCK_METHOD(void, version, (), (override));
-    MOCK_METHOD2(standardStartup, int(int, char**));
+    MOCK_METHOD(int, standardStartup, (int, char**), (override));
-    MOCK_METHOD4(runInner, int(int, char**, ILogOutputter*, StartupFunc));
+    MOCK_METHOD(int, runInner, (int, char**, ILogOutputter*, StartupFunc), (override));
-    MOCK_METHOD0(startNode, void());
+    MOCK_METHOD(void, startNode, (), (override));
-    MOCK_METHOD0(mainLoop, int());
+    MOCK_METHOD(int, mainLoop, (), (override));
-    MOCK_METHOD2(foregroundStartup, int(int, char**));
+    MOCK_METHOD(int, foregroundStartup, (int, char**), (override));
-    MOCK_METHOD0(createScreen, synergy::Screen*());
+    MOCK_METHOD(synergy::Screen*, createScreen, (), (override));
 };

src/test/mock/synergy/MockArgParser.h

@@ -28,6 +28,6 @@ class MockArgParser : public ArgParser
 public:
     MockArgParser() : ArgParser(NULL) { }
 
-    MOCK_METHOD3(parseGenericArgs, bool(int, const char* const*, int&));
+    MOCK_METHOD(bool, parseGenericArgs, (int, const char* const*, int&));
-    MOCK_METHOD0(checkUnexpectedArgs, bool());
+    MOCK_METHOD(bool, checkUnexpectedArgs, ());
 };

src/test/mock/synergy/MockEventQueue.h

@@ -25,43 +25,43 @@
 class MockEventQueue : public IEventQueue
 {
 public:
-    MOCK_METHOD0(loop, void());
+    MOCK_METHOD(void, loop, (), (override));
-    MOCK_METHOD2(newOneShotTimer, EventQueueTimer*(double, void*));
+    MOCK_METHOD(EventQueueTimer*, newOneShotTimer, (double, void*), (override));
-    MOCK_METHOD2(newTimer, EventQueueTimer*(double, void*));
+    MOCK_METHOD(EventQueueTimer*, newTimer, (double, void*), (override));
-    MOCK_METHOD2(getEvent, bool(Event&, double));
+    MOCK_METHOD(bool, getEvent, (Event&, double), (override));
-    MOCK_METHOD1(adoptBuffer, void(IEventQueueBuffer*));
+    MOCK_METHOD(void, adoptBuffer, (IEventQueueBuffer*), (override));
-    MOCK_METHOD2(registerTypeOnce, Event::Type(Event::Type&, const char*));
+    MOCK_METHOD(Event::Type, registerTypeOnce, (Event::Type&, const char*), (override));
-    MOCK_METHOD1(removeHandlers, void(void*));
+    MOCK_METHOD(void, removeHandlers, (void*), (override));
-    MOCK_METHOD1(registerType, Event::Type(const char*));
+    MOCK_METHOD(Event::Type, registerType, (const char*));
-    MOCK_CONST_METHOD0(isEmpty, bool());
+    MOCK_METHOD(bool, isEmpty, (), (const, override));
-    MOCK_METHOD3(adoptHandler, void(Event::Type, void*, IEventJob*));
+    MOCK_METHOD(void, adoptHandler, (Event::Type, void*, IEventJob*), (override));
-    MOCK_METHOD1(getTypeName, const char*(Event::Type));
+    MOCK_METHOD(const char*, getTypeName, (Event::Type), (override));
-    MOCK_METHOD1(addEvent, void(const Event&));
+    MOCK_METHOD(void, addEvent, (const Event&), (override));
-    MOCK_METHOD2(removeHandler, void(Event::Type, void*));
+    MOCK_METHOD(void, removeHandler, (Event::Type, void*), (override));
-    MOCK_METHOD1(dispatchEvent, bool(const Event&));
+    MOCK_METHOD(bool, dispatchEvent, (const Event&), (override));
-    MOCK_CONST_METHOD2(getHandler, IEventJob*(Event::Type, void*));
+    MOCK_METHOD(IEventJob*, getHandler, (Event::Type, void*), (const, override));
-    MOCK_METHOD1(deleteTimer, void(EventQueueTimer*));
+    MOCK_METHOD(void, deleteTimer, (EventQueueTimer*), (override));
-    MOCK_CONST_METHOD1(getRegisteredType, Event::Type(const String&));
+    MOCK_METHOD(Event::Type, getRegisteredType, (const String&), (const, override));
-    MOCK_METHOD0(getSystemTarget, void*());
+    MOCK_METHOD(void*, getSystemTarget, (), (override));
-    MOCK_METHOD0(forClient, ClientEvents&());
+    MOCK_METHOD(ClientEvents&, forClient, (), (override));
-    MOCK_METHOD0(forIStream, IStreamEvents&());
+    MOCK_METHOD(IStreamEvents&, forIStream, (), (override));
-    MOCK_METHOD0(forIpcClient, IpcClientEvents&());
+    MOCK_METHOD(IpcClientEvents&, forIpcClient, (), (override));
-    MOCK_METHOD0(forIpcClientProxy, IpcClientProxyEvents&());
+    MOCK_METHOD(IpcClientProxyEvents&, forIpcClientProxy, (), (override));
-    MOCK_METHOD0(forIpcServer, IpcServerEvents&());
+    MOCK_METHOD(IpcServerEvents&, forIpcServer, (), (override));
-    MOCK_METHOD0(forIpcServerProxy, IpcServerProxyEvents&());
+    MOCK_METHOD(IpcServerProxyEvents&, forIpcServerProxy, (), (override));
-    MOCK_METHOD0(forIDataSocket, IDataSocketEvents&());
+    MOCK_METHOD(IDataSocketEvents&, forIDataSocket, (), (override));
-    MOCK_METHOD0(forIListenSocket, IListenSocketEvents&());
+    MOCK_METHOD(IListenSocketEvents&, forIListenSocket, (), (override));
-    MOCK_METHOD0(forISocket, ISocketEvents&());
+    MOCK_METHOD(ISocketEvents&, forISocket, (), (override));
-    MOCK_METHOD0(forOSXScreen, OSXScreenEvents&());
+    MOCK_METHOD(OSXScreenEvents&, forOSXScreen, (), (override));
-    MOCK_METHOD0(forClientListener, ClientListenerEvents&());
+    MOCK_METHOD(ClientListenerEvents&, forClientListener, (), (override));
-    MOCK_METHOD0(forClientProxy, ClientProxyEvents&());
+    MOCK_METHOD(ClientProxyEvents&, forClientProxy, (), (override));
-    MOCK_METHOD0(forClientProxyUnknown, ClientProxyUnknownEvents&());
+    MOCK_METHOD(ClientProxyUnknownEvents&, forClientProxyUnknown, (), (override));
-    MOCK_METHOD0(forServer, ServerEvents&());
+    MOCK_METHOD(ServerEvents&, forServer, (), (override));
-    MOCK_METHOD0(forServerApp, ServerAppEvents&());
+    MOCK_METHOD(ServerAppEvents&, forServerApp, (), (override));
-    MOCK_METHOD0(forIKeyState, IKeyStateEvents&());
+    MOCK_METHOD(IKeyStateEvents&, forIKeyState, (), (override));
-    MOCK_METHOD0(forIPrimaryScreen, IPrimaryScreenEvents&());
+    MOCK_METHOD(IPrimaryScreenEvents&, forIPrimaryScreen, (), (override));
-    MOCK_METHOD0(forIScreen, IScreenEvents&());
+    MOCK_METHOD(IScreenEvents&, forIScreen, (), (override));
-    MOCK_METHOD0(forClipboard, ClipboardEvents&());
+    MOCK_METHOD(ClipboardEvents&, forClipboard, (), (override));
-    MOCK_METHOD0(forFile, FileEvents&());
+    MOCK_METHOD(FileEvents&, forFile, (), (override));
-    MOCK_CONST_METHOD0(waitForReady, void());
+    MOCK_METHOD(void, waitForReady, (), (const, override));
 };

src/test/mock/synergy/MockKeyMap.h

@@ -25,12 +25,11 @@
 class MockKeyMap : public synergy::KeyMap
 {
 public:
-    MOCK_METHOD1(swap, void(KeyMap&));
+    MOCK_METHOD(void, swap, (KeyMap&), (override));
-    MOCK_METHOD0(finish, void());
+    MOCK_METHOD(void, finish, (), (override));
-    MOCK_METHOD2(foreachKey, void(ForeachKeyCallback, void*));
+    MOCK_METHOD(void, foreachKey, (ForeachKeyCallback, void*), (override));
-    MOCK_METHOD1(addHalfDuplexModifier, void(KeyID));
+    MOCK_METHOD(void, addHalfDuplexModifier, (KeyID), (override));
-    MOCK_CONST_METHOD2(isHalfDuplex, bool(KeyID, KeyButton));
+    MOCK_METHOD(bool, isHalfDuplex, (KeyID, KeyButton), (const, override));
-    MOCK_CONST_METHOD7(mapKey, const KeyMap::KeyItem*(
+    MOCK_METHOD(const KeyMap::KeyItem*, mapKey, (Keystrokes&, KeyID, SInt32, ModifierToKeys&, KeyModifierMask&,
-        Keystrokes&, KeyID, SInt32, ModifierToKeys&, KeyModifierMask&,
+        KeyModifierMask, bool), (const, override));
-        KeyModifierMask, bool));
 };

src/test/mock/synergy/MockKeyState.h

@@ -40,13 +40,13 @@ public:
     {
     }
 
-    MOCK_CONST_METHOD0(pollActiveGroup, SInt32());
+    MOCK_METHOD(SInt32, pollActiveGroup, (), (const, override));
-    MOCK_CONST_METHOD0(pollActiveModifiers, KeyModifierMask());
+    MOCK_METHOD(KeyModifierMask, pollActiveModifiers, (), (const, override));
-    MOCK_METHOD0(fakeCtrlAltDel, bool());
+    MOCK_METHOD(bool, fakeCtrlAltDel, (), (override));
-    MOCK_METHOD1(getKeyMap, void(synergy::KeyMap&));
+    MOCK_METHOD(void, getKeyMap, (synergy::KeyMap&), (override));
-    MOCK_METHOD1(fakeKey, void(const Keystroke&));
+    MOCK_METHOD(void, fakeKey, (const Keystroke&), (override));
-    MOCK_METHOD1(fakeMediaKey, bool(KeyID));
+    MOCK_METHOD(bool, fakeMediaKey, (KeyID), (override));
-    MOCK_CONST_METHOD1(pollPressedKeys, void(KeyButtonSet&));
+    MOCK_METHOD(void, pollPressedKeys, (KeyButtonSet&), (const, override));
 };
 
 typedef ::testing::NiceMock<MockKeyState> KeyStateImpl;

src/test/mock/synergy/MockScreen.h

@@ -27,10 +27,10 @@ class MockScreen : public synergy::Screen
 {
 public:
     MockScreen() : synergy::Screen() { }
-    MOCK_METHOD0(disable, void());
+    MOCK_METHOD(void, disable, (), (override));
-    MOCK_CONST_METHOD4(getShape, void(SInt32&, SInt32&, SInt32&, SInt32&));
+    MOCK_METHOD(void, getShape, (SInt32&, SInt32&, SInt32&, SInt32&), (const, override));
-    MOCK_CONST_METHOD2(getCursorPos, void(SInt32&, SInt32&));
+    MOCK_METHOD(void, getCursorPos, (SInt32&, SInt32&), (const, override));
-    MOCK_METHOD0(resetOptions, void());
+    MOCK_METHOD(void, resetOptions, (), (override));
-    MOCK_METHOD1(setOptions, void(const OptionsList&));
+    MOCK_METHOD(void, setOptions, (const OptionsList&), (override));
-    MOCK_METHOD0(enable, void());
+    MOCK_METHOD(void, enable, (), (override));
 };

src/test/unittests/synergy/ProtocolUtilTests.cpp

@@ -266,7 +266,7 @@ TEST_P(ReadfIntTestFixture, readf_int)
     EXPECT_EQ(Expected, Actual);
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
         ReadfIntTests,
         ReadfIntTestFixture,
         ::testing::Values(
@@ -323,7 +323,7 @@ TEST_P(ReadfIntVectorTestFixture, readf_int_vector)
     }
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
         ReadfIntVectorTests,
         ReadfIntVectorTestFixture,
         ::testing::Values(
@@ -388,7 +388,7 @@ TEST_P(ReadfIntAndStringTest, readf_int_and_string)
     EXPECT_EQ(ExpectedString, ActualString);
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
         IntAndStringTest,
         ReadfIntAndStringTest,
         ::testing::Values(
@@ -548,7 +548,7 @@ TEST_P(WriteIntTest, write_int)
     }
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
         WriteIntTest,
         WriteIntTest,
         ::testing::Values(
@@ -586,7 +586,7 @@ TEST_P(WriteIntVectorTest, write_vector_int)
     }
 }
 
-INSTANTIATE_TEST_CASE_P(
+INSTANTIATE_TEST_SUITE_P(
         WriteIntVectorTest,
         WriteIntVectorTest,
         ::testing::Values(