Issue 2005 - Refactor working with strings in InputBuffer and OutputBuffer

test/CommunicationTest.cpp

 /*
- * This file is part of Adblock Plus <http://adblockplus.org/>,
- * Copyright (C) 2006-2014 Eyeo GmbH
+ * 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.
  *
@@ skipping 20 matching lines @@
   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]
   {
-    while(!client)
+    for (int i = 0; !client && i < 100; ++i)

[Eric, 2015/05/14 13:53:38]

There's no need to guard the loop with the term "!client" if you move the
assertion below to appear before the declaration of 'clientThread'

[sergei, 2015/05/15 09:45:55]

Before declaration of `clientThread` `client` is always `nullptr`.

     {
       try
       {
         client.reset(new Communication::Pipe(pipeName, Communication::Pipe::MODE_CONNECT));
       }
       catch(...)
       {
-        std::this_thread::yield();
+        std::this_thread::sleep_for(i * std::chrono::milliseconds(20));
       }
     }
   });
   Communication::Pipe server(pipeName, Communication::Pipe::MODE_CREATE);
   clientThread.join();
-
+  ASSERT_TRUE(client);

[Eric, 2015/05/14 13:53:38]

This assertion should appear before the declaration of 'clientThread'. If you're
going to check it at all and fail the test based on it, you should test it as
soon as possible.

   // send to the server
   {
     Communication::OutputBuffer message;
-    message << Communication::ProcType::PROC_IS_WHITELISTED_URL
+    message << Communication::ProcType::PROC_GET_WHITELISTING_FITER
       << 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);
+    EXPECT_EQ(Communication::ProcType::PROC_GET_WHITELISTING_FITER, 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);
@@ skipping 63 matching lines @@
 
 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)
 {
@@ skipping 67 matching lines @@
   {
     Communication::OutputBuffer outputBuffer;
     outputBuffer << src;
     Communication::InputBuffer inputBuffer(outputBuffer.Get());
     std::vector<std::wstring> dst;
     inputBuffer >> dst;
     return dst;
   }
 }
 
-TEST(InputOutputBuffersTests, InputOutputBufferEmptyStrings)
+TEST(InputOutputBuffersTest, EmptyStrings)
 {
   SendReceiveStrings(std::vector<std::string>());
 }
 
-TEST(InputOutputBuffersTests, InputOutputBufferEmptyStringsToWideStrings)
+TEST(InputOutputBuffersTest, EmptyStringsToWideStrings)
 {
   EXPECT_EQ(0u, SendReceiveStringsToWStrings(std::vector<std::string>()).size());
 }
 
-TEST(InputOutputBuffersTests, InputOutputBufferStringsWithOneValue)
+TEST(InputOutputBuffersTest, StringsWithOneValue)
 {
   std::vector<std::string> src;
   src.emplace_back("string1");
   SendReceiveStrings(src);
 }
 
-TEST(InputOutputBuffersTests, InputOutputBufferStringsWithOneValueToWStrings)
+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(InputOutputBuffersTests, InputOutputBufferWithMultivalueStrings)
+TEST(InputOutputBuffersTest, WithMultivalueStrings)
 {
   std::vector<std::string> src;
   src.emplace_back("string1");
   src.emplace_back("str2");
   src.emplace_back("value");
   SendReceiveStrings(src);
 }
 
-TEST(InputOutputBuffersTests, InputOutputBufferWithMultivalueStringsToWStrings)
+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]);
 }