Mojo: re-organize public tests

mojo/public/tests/bindings/sample_service_unittests.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 #include <ostream>
 #include <string>
 
-#include "mojo/public/tests/simple_bindings_support.h"
+#include "mojo/public/tests/bindings/simple_bindings_support.h"
 #include "mojom/sample_service.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 
 template <>
 class TypeConverter<sample::Bar, int32_t> {
  public:
   static int32_t ConvertTo(const sample::Bar& bar) {
     return static_cast<int32_t>(bar.alpha()) << 16 |
            static_cast<int32_t>(bar.beta()) << 8 |
            static_cast<int32_t>(bar.gamma());
   }
 };
 
 }  // namespace mojo
 
 namespace sample {
+namespace {
 
-// Set this variable to true to print the binary message in hex.
-bool g_dump_message_as_hex = true;
+// Set this variable to true to print the message in hex.
+bool g_dump_message_as_hex = false;
+
+// Set this variable to true to print the message in human readable form.
+bool g_dump_message_as_text = false;
 
 // Make a sample |Foo|.
 Foo MakeFoo() {
   mojo::String name("foopy");
 
   Bar::Builder bar;
   bar.set_alpha(20);
   bar.set_beta(40);
   bar.set_gamma(60);
   bar.set_type(BAR_VERTICAL);
@@ skipping 87 matching lines @@
     EXPECT_EQ(static_cast<uint8_t>(foo.data().size() - i), foo.data()[i]) << i;
   }
 
   EXPECT_FALSE(foo.input_streams().is_null());
   EXPECT_EQ(2u, foo.input_streams().size());
 
   EXPECT_FALSE(foo.output_streams().is_null());
   EXPECT_EQ(2u, foo.output_streams().size());
 }
 
-static void PrintSpacer(int depth) {
+void PrintSpacer(int depth) {
   for (int i = 0; i < depth; ++i)
     std::cout << "   ";
 }
 
-static void Print(int depth, const char* name, bool value) {
+void Print(int depth, const char* name, bool value) {
   PrintSpacer(depth);
   std::cout << name << ": " << (value ? "true" : "false") << std::endl;
 }
 
-static void Print(int depth, const char* name, int32_t value) {
+void Print(int depth, const char* name, int32_t value) {
   PrintSpacer(depth);
   std::cout << name << ": " << value << std::endl;
 }
 
-static void Print(int depth, const char* name, uint8_t value) {
+void Print(int depth, const char* name, uint8_t value) {
   PrintSpacer(depth);
   std::cout << name << ": " << uint32_t(value) << std::endl;
 }
 
-static void Print(int depth, const char* name, mojo::Handle value) {
+void Print(int depth, const char* name, mojo::Handle value) {
   PrintSpacer(depth);
   std::cout << name << ": 0x" << std::hex << value.value() << std::endl;
 }
 
-static void Print(int depth, const char* name, const mojo::String& str) {
+void Print(int depth, const char* name, const mojo::String& str) {
   std::string s = str.To<std::string>();
   PrintSpacer(depth);
   std::cout << name << ": \"" << str.To<std::string>() << "\"" << std::endl;
 }
 
-static void Print(int depth, const char* name, const Bar& bar) {
+void Print(int depth, const char* name, const Bar& bar) {
   PrintSpacer(depth);
   std::cout << name << ":" << std::endl;
   if (!bar.is_null()) {
     ++depth;
     Print(depth, "alpha", bar.alpha());
     Print(depth, "beta", bar.beta());
     Print(depth, "gamma", bar.gamma());
     Print(depth, "packed", bar.To<int32_t>());
     --depth;
   }
 }
 
 template <typename T>
-static void Print(int depth, const char* name,
+void Print(int depth, const char* name,
                   const mojo::Passable<T>& passable) {
   Print(depth, name, passable.get());
 }
 
 template <typename T>
-static void Print(int depth, const char* name, const mojo::Array<T>& array) {
+void Print(int depth, const char* name, const mojo::Array<T>& array) {
   PrintSpacer(depth);
   std::cout << name << ":" << std::endl;
   if (!array.is_null()) {
     ++depth;
     for (size_t i = 0; i < array.size(); ++i) {
       std::stringstream buf;
       buf << i;
       Print(depth, buf.str().data(), array.at(i));
     }
     --depth;
   }
 }
 
-static void Print(int depth, const char* name, const Foo& foo) {
+void Print(int depth, const char* name, const Foo& foo) {
   PrintSpacer(depth);
   std::cout << name << ":" << std::endl;
   if (!foo.is_null()) {
     ++depth;
     Print(depth, "name", foo.name());
     Print(depth, "x", foo.x());
     Print(depth, "y", foo.y());
     Print(depth, "a", foo.a());
     Print(depth, "b", foo.b());
     Print(depth, "c", foo.c());
     Print(depth, "bar", foo.bar());
     Print(depth, "extra_bars", foo.extra_bars());
     Print(depth, "data", foo.data());
     Print(depth, "source", foo.source().get());
     Print(depth, "input_streams", foo.input_streams());
     Print(depth, "output_streams", foo.output_streams());
     --depth;
   }
 }
 
-static void DumpHex(const uint8_t* bytes, uint32_t num_bytes) {
+void DumpHex(const uint8_t* bytes, uint32_t num_bytes) {
   for (uint32_t i = 0; i < num_bytes; ++i) {
     std::cout << std::setw(2) << std::setfill('0') << std::hex <<
         uint32_t(bytes[i]);
 
     if (i % 16 == 15) {
       std::cout << std::endl;
       continue;
     }
 
     if (i % 2 == 1)
       std::cout << " ";
     if (i % 8 == 7)
       std::cout << " ";
   }
 }
 
 class ServiceImpl : public Service {
  public:
   virtual void Frobinate(const Foo& foo, int32_t baz,
                          mojo::ScopedMessagePipeHandle port)
       MOJO_OVERRIDE {
     // Users code goes here to handle the incoming Frobinate message.
 
     // We mainly check that we're given the expected arguments.
     CheckFoo(foo);
     EXPECT_EQ(BAZ_EXTRA, baz);
 
-    // Also dump the Foo structure and all of its members.
-    // TODO(vtl): Make it optional, so that the test spews less?
-    std::cout << "Frobinate:" << std::endl;
-    int depth = 1;
-    Print(depth, "foo", foo);
-    Print(depth, "baz", baz);
-    Print(depth, "port", port.get());
+    if (g_dump_message_as_text) {
+      // Also dump the Foo structure and all of its members.
+      std::cout << "Frobinate:" << std::endl;
+      int depth = 1;
+      Print(depth, "foo", foo);
+      Print(depth, "baz", baz);
+      Print(depth, "port", port.get());
+    }
   }
 };
 
 class SimpleMessageReceiver : public mojo::MessageReceiver {
  public:
   virtual bool Accept(mojo::Message* message) MOJO_OVERRIDE {
     // Imagine some IPC happened here.
 
     if (g_dump_message_as_hex) {
       DumpHex(reinterpret_cast<const uint8_t*>(message->data),
               message->data->header.num_bytes);
     }
 
     // In the receiving process, an implementation of ServiceStub is known to
     // the system. It receives the incoming message.
     ServiceImpl impl;
 
     ServiceStub stub(&impl);
     return stub.Accept(message);
   }
 };
 
+}  // namespace
+
 TEST(BindingsSampleTest, Basic) {
   mojo::test::SimpleBindingsSupport bindings_support;
   SimpleMessageReceiver receiver;
 
   // User has a proxy to a Service somehow.
   Service* service = new ServiceProxy(&receiver);
 
   // User constructs a message to send.
 
   // Notice that it doesn't matter in what order the structs / arrays are
   // allocated. Here, the various members of Foo are allocated before Foo is
   // allocated.
 
   mojo::AllocationScope scope;
 
   Foo foo = MakeFoo();
   CheckFoo(foo);
 
   mojo::ScopedMessagePipeHandle port0, port1;
   mojo::CreateMessagePipe(&port0, &port1);
 
   service->Frobinate(foo, Service::BAZ_EXTRA, port0.Pass());
 }
 
 }  // namespace sample