Issue 2005 - Refactor working with strings in InputBuffer and OutputBuffer

test/CommunicationTest.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2015 Eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus 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 Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <gtest/gtest.h>
 
+#include <thread>
+#include <chrono>
+#include <memory>
 #include "../src/shared/AutoHandle.h"
 #include "../src/shared/Communication.h"
 
 const std::wstring pipeName(L"\\\\.\\pipe\\adblockplustests");
 
+TEST(CommunicationTest, PipeConnect)
+{
+  auto serverThread = std::thread([]
+  {
+    Communication::Pipe pipe(pipeName, Communication::Pipe::MODE_CREATE);
+  });
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  ASSERT_NO_THROW(Communication::Pipe pipe(pipeName, Communication::Pipe::MODE_CONNECT));
+  serverThread.join();
+}
+
+TEST(CommunicationTest, PipeSendReceive)
+{
+  std::unique_ptr<Communication::Pipe> client;
+  auto clientThread = std::thread([&client]
+  {
+    for (int i = 0; !client && i < 100; ++i)
+    {
+      try
+      {
+        client.reset(new Communication::Pipe(pipeName, Communication::Pipe::MODE_CONNECT));
+      }
+      catch(...)
+      {
+        std::this_thread::sleep_for(i * std::chrono::milliseconds(20));
+      }
+    }
+  });
+  Communication::Pipe server(pipeName, Communication::Pipe::MODE_CREATE);
+  clientThread.join();
+  ASSERT_TRUE(client);
+  // send to the server
+  {
+    Communication::OutputBuffer message;
+    message << Communication::ProcType::PROC_IS_WHITELISTED_URL
+      << std::string("This is a test message") << 64ll << 32 << true << false;
+    client->WriteMessage(message);
+  }
+  // receive on the server and send back
+  {
+    Communication::OutputBuffer response;
+    Communication::InputBuffer message = server.ReadMessage();
+    Communication::ProcType proc;
+    message >> proc;
+    EXPECT_EQ(Communication::ProcType::PROC_IS_WHITELISTED_URL, proc);
+    response << Communication::ProcType::PROC_IS_FIRST_RUN_ACTION_NEEDED;
+
+    std::string text;
+    message >> text;
+    EXPECT_EQ("This is a test message", text);
+    response << std::string("Response");
+
+    int64_t integer64;
+    message >> integer64;
+    EXPECT_EQ(64ll, integer64);
+    response << 46ll;
+
+    int32_t integer32;
+    message >> integer32;
+    EXPECT_EQ(32, integer32);
+    response << 23;
+
+    bool boolean;
+    message >> boolean;
+    EXPECT_TRUE(boolean);
+    response << false;
+
+    message >> boolean;
+    EXPECT_FALSE(boolean);
+    response << true;
+
+    server.WriteMessage(response);
+  }
+
+  // receive on the client
+  {
+    Communication::InputBuffer message = client->ReadMessage();
+    Communication::ProcType proc;
+    message >> proc;
+    EXPECT_EQ(Communication::ProcType::PROC_IS_FIRST_RUN_ACTION_NEEDED, proc);
+
+    std::string text;
+    message >> text;
+    EXPECT_EQ("Response", text);
+
+    int64_t integer64;
+    message >> integer64;
+    EXPECT_EQ(46ll, integer64);
+
+    int32_t integer32;
+    message >> integer32;
+    EXPECT_EQ(23, integer32);
+
+    bool boolean;
+    message >> boolean;
+    EXPECT_FALSE(boolean);
+
+    message >> boolean;
+    EXPECT_TRUE(boolean);
+  }
+}
+
 namespace
 {
-  DWORD WINAPI CreatePipe(LPVOID param)
-  {
-    Communication::Pipe pipe(pipeName, Communication::Pipe::MODE_CREATE);
-    return 0;
-  }
-
-  DWORD WINAPI ReceiveSend(LPVOID param)
-  {
-    Communication::Pipe pipe(pipeName, Communication::Pipe::MODE_CREATE);
-
-    Communication::InputBuffer message = pipe.ReadMessage();
-
-    std::string stringValue;
-    std::wstring wstringValue;
-    int64_t int64Value;
-    int32_t int32Value;
-    bool boolValue;
-    message >> stringValue >> wstringValue >> int64Value >> int32Value >> boolValue;
-
-    stringValue += " Received";
-    wstringValue += L" \u043f\u0440\u0438\u043d\u044f\u0442\u043e";
-    int64Value += 1;
-    int32Value += 2;
-    boolValue = !boolValue;
-
-    Communication::OutputBuffer response;
-    response << stringValue << wstringValue << int64Value << int32Value << boolValue;
-    pipe.WriteMessage(response);
-
-    return 0;
-  }
-}
-
-TEST(CommunicationTest, ConnectPipe)
-{
-  AutoHandle thread(CreateThread(0, 0, CreatePipe, 0, 0, 0));
-
-  Sleep(100);
-
-  ASSERT_NO_THROW(Communication::Pipe pipe(pipeName, Communication::Pipe::MODE_CONNECT));
-}
-
-TEST(CommunicationTest, SendReceive)
-{
-  AutoHandle thread(CreateThread(0, 0, ReceiveSend, 0, 0, 0));
-
-  Sleep(100);
-
-  Communication::Pipe pipe(pipeName, Communication::Pipe::MODE_CONNECT);
-
-  Communication::OutputBuffer message;
-  message << std::string("Foo") << std::wstring(L"Bar") << int64_t(9876543210L) << int32_t(5) << true;
-  pipe.WriteMessage(message);
-
-  Communication::InputBuffer response = pipe.ReadMessage();
-
-  std::string stringValue;
-  std::wstring wstringValue;
-  int64_t int64Value;
-  int32_t int32Value;
-  bool boolValue;
-
-  ASSERT_ANY_THROW(response >> wstringValue);
-  ASSERT_ANY_THROW(response >> int64Value);
-  ASSERT_ANY_THROW(response >> int32Value);
-  ASSERT_ANY_THROW(response >> boolValue);
-
-  response >> stringValue >> wstringValue;
-
-  ASSERT_ANY_THROW(response >> stringValue);
-  ASSERT_ANY_THROW(response >> wstringValue);
-  ASSERT_ANY_THROW(response >> int32Value);
-  ASSERT_ANY_THROW(response >> boolValue);
-
-  response >> int64Value >> int32Value >> boolValue;
-
-  ASSERT_ANY_THROW(response >> stringValue);
-  ASSERT_ANY_THROW(response >> wstringValue);
-  ASSERT_ANY_THROW(response >> int64Value);
-  ASSERT_ANY_THROW(response >> int32Value);
-  ASSERT_ANY_THROW(response >> boolValue);
-
-  ASSERT_EQ("Foo Received", stringValue);
-  ASSERT_EQ(L"Bar \u043f\u0440\u0438\u043d\u044f\u0442\u043e", wstringValue);
-  ASSERT_EQ(9876543211L, int64Value);
-  ASSERT_EQ(7, int32Value);
-  ASSERT_FALSE(boolValue);
-}
-
-void SendReceiveStrings(const std::vector<std::string>& src)
-{
-  Communication::OutputBuffer outputBuffer;
-  outputBuffer << src;
-  Communication::InputBuffer inputBuffer(outputBuffer.Get());
-  std::vector<std::string> dst;
-  inputBuffer >> dst;
-  auto dstSize = dst.size();
-  ASSERT_EQ(dstSize, src.size());
-  for (auto i = 0; i < dstSize; ++i)
-  {
-    EXPECT_EQ(dst[i], src[i]);
-  }
-}
-
-TEST(InputOutputBuffersTests, EmptyStrings)
+  template<typename TestedType, typename AnotherType>
+  void SendReceiveTypes(TestedType value, AnotherType anotherTypeValue)
+  {
+    Communication::OutputBuffer message;
+    message << anotherTypeValue << value;
+    Communication::InputBuffer response(message.Get());
+    TestedType received;
+    ASSERT_ANY_THROW(response >> received);
+    AnotherType anotherTypeValueReceived;
+    response >> anotherTypeValueReceived;
+    response >> received;
+    EXPECT_EQ(value, received);
+  }
+}
+
+TEST(CommunicationTest, TypeProc)
+{
+  SendReceiveTypes(Communication::ProcType::PROC_GET_ELEMHIDE_SELECTORS, std::string("non-ProcType"));
+}
+
+TEST(CommunicationTest, TypeString)
+{
+  int32_t nonStringTypeValue = 10;
+  SendReceiveTypes(std::string("stringValue"), nonStringTypeValue);
+}
+
+TEST(CommunicationTest, SendReceiveEmptyString)
+{
+  Communication::OutputBuffer message;
+  message << std::string();
+  Communication::InputBuffer response(message.Get());
+  std::string received = "clean me";
+  response >> received;
+  EXPECT_EQ("", received);
+}
+
+TEST(CommunicationTest, TypeStringSendWideReceiveWide)
+{
+  int32_t nonStringTypeValue = 10;
+  SendReceiveTypes(std::wstring(L"stringValue"), nonStringTypeValue);
+}
+
+TEST(CommunicationTest, SendString_ReceiveWString)
+{
+  Communication::OutputBuffer message;
+  message << std::string("test");
+  Communication::InputBuffer response(message.Get());
+  std::wstring received;
+  response >> received;
+  EXPECT_EQ(L"test", received);
+}
+
+TEST(CommunicationTest, SendWString_ReceiveString)
+{
+  Communication::OutputBuffer message;
+  message << std::wstring(L"test");
+  Communication::InputBuffer response(message.Get());
+  std::string received;
+  response >> received;
+  EXPECT_EQ("test", received);
+}
+
+TEST(CommunicationTest, SendStrings_ReceiveWStrings)
+{
+  Communication::OutputBuffer message;
+  std::vector<std::string> strings;
+  strings.emplace_back("test0");
+  strings.emplace_back("test1");
+  message << strings;
+  Communication::InputBuffer response(message.Get());
+  std::vector<std::wstring> received;
+  response >> received;
+  ASSERT_EQ(2u, received.size());
+  EXPECT_EQ(L"test0", received[0]);
+  EXPECT_EQ(L"test1", received[1]);
+}
+
+TEST(CommunicationTest, TypeInt64)
+{
+  SendReceiveTypes<int64_t>(10, std::string("non-ProcType"));
+}
+
+TEST(CommunicationTest, TypeInt32)
+{
+  SendReceiveTypes<int32_t>(10, std::string("non-ProcType"));
+}
+
+TEST(CommunicationTest, TypeBool)
+{
+  SendReceiveTypes<bool>(true, std::string("non-ProcType"));
+  SendReceiveTypes<bool>(false, std::string("non-ProcType"));
+}
+
+namespace
+{
+  void SendReceiveStrings(const std::vector<std::string>& src)
+  {
+    Communication::OutputBuffer outputBuffer;
+    outputBuffer << src;
+    Communication::InputBuffer inputBuffer(outputBuffer.Get());
+    std::vector<std::string> dst;
+    inputBuffer >> dst;
+    auto dstSize = dst.size();
+    ASSERT_EQ(src.size(), dstSize);
+    for (auto i = 0u; i < dstSize; ++i)
+    {
+      EXPECT_EQ(src[i], dst[i]);
+    }
+  }
+
+  std::vector<std::wstring> SendReceiveStringsToWStrings(const std::vector<std::string>& src)
+  {
+    Communication::OutputBuffer outputBuffer;
+    outputBuffer << src;
+    Communication::InputBuffer inputBuffer(outputBuffer.Get());
+    std::vector<std::wstring> dst;
+    inputBuffer >> dst;
+    return dst;
+  }
+}
+
+TEST(InputOutputBuffersTest, EmptyStrings)
 {
   SendReceiveStrings(std::vector<std::string>());
 }
 
-TEST(InputOutputBuffersTests, StringsWithOneValue)
+TEST(InputOutputBuffersTest, EmptyStringsToWideStrings)
+{
+  EXPECT_EQ(0u, SendReceiveStringsToWStrings(std::vector<std::string>()).size());
+}
+
+TEST(InputOutputBuffersTest, StringsWithOneValue)
 {
   std::vector<std::string> src;
   src.emplace_back("string1");
   SendReceiveStrings(src);
 }
 
-TEST(InputOutputBuffersTests, MultivalueStrings)
+TEST(InputOutputBuffersTest, StringsWithOneValueToWStrings)
+{
+  std::vector<std::string> src;
+  src.emplace_back("string1");
+  auto dst = SendReceiveStringsToWStrings(src);
+  ASSERT_EQ(1u, dst.size());
+  EXPECT_EQ(L"string1", dst[0]);
+}
+
+TEST(InputOutputBuffersTest, WithMultivalueStrings)
 {
   std::vector<std::string> src;
   src.emplace_back("string1");
   src.emplace_back("str2");
   src.emplace_back("value");
   SendReceiveStrings(src);
+}
+
+TEST(InputOutputBuffersTest, WithMultivalueStringsToWStrings)
+{
+  std::vector<std::string> src;
+  src.emplace_back("string1");
+  src.emplace_back("str2");
+  src.emplace_back("value");
+  auto dst = SendReceiveStringsToWStrings(src);
+  ASSERT_EQ(3u, dst.size());
+  EXPECT_EQ(L"string1", dst[0]);
+  EXPECT_EQ(L"str2", dst[1]);
+  EXPECT_EQ(L"value", dst[2]);
 }