Pass data down pipes in mojo fuzzing tests.

mojo/apps/js/test/js_to_cpp_unittest.cc

 // Copyright 2014 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 "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "gin/public/isolate_holder.h"
 #include "mojo/apps/js/mojo_runner_delegate.h"
 #include "mojo/apps/js/test/js_to_cpp.mojom.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/common/test/test_utils.h"
 #include "mojo/public/cpp/bindings/allocation_scope.h"
 #include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/cpp/system/core.h"
 #include "mojo/public/cpp/system/macros.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace js {
+
+// Global value updated by some checks to prevent compilers from optimizing
+// reads out of existence.
+uint32 g_waste_accumulator = 0;
+
 namespace {
 
 // Negative numbers with different values in each byte, the last of
 // which can survive promotion to double and back.
 const int8  kExpectedInt8Value = -65;
 const int16 kExpectedInt16Value = -16961;
 const int32 kExpectedInt32Value = -1145258561;
 const int64 kExpectedInt64Value = -77263311946305LL;
 
 // Positive numbers with different values in each byte, the last of
@@ skipping 68 matching lines @@
     EXPECT_NAN(arg.float_nan());
     EXPECT_EQ(kExpectedDoubleVal, arg.double_val());
     EXPECT_EQ(kExpectedDoubleInf, arg.double_inf());
     EXPECT_NAN(arg.double_nan());
     EXPECT_EQ(std::string("coming"), arg.name().To<std::string>());
     EXPECT_EQ(std::string("one"), arg.string_array()[0].To<std::string>());
     EXPECT_EQ(std::string("two"), arg.string_array()[1].To<std::string>());
     EXPECT_EQ(std::string("three"), arg.string_array()[2].To<std::string>());
 }
 
+void CheckDataPipe(MojoHandle data_pipe_handle) {
+  char buffer[100];
+  uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
+  MojoResult result = MojoReadData(
+      data_pipe_handle, buffer, &buffer_size, MOJO_READ_DATA_FLAG_NONE);
+  EXPECT_EQ(MOJO_RESULT_OK, result);
+  EXPECT_EQ(64u, buffer_size);
+  for (int i = 0; i < 64; ++i) {
+    EXPECT_EQ(i, buffer[i]);
+  }
+}
+
+void CheckCorruptedString(const mojo::String& arg) {
+  // The values don't matter so long as all accesses are within bounds.
+  std::string name = arg.To<std::string>();
+  for (size_t i = 0; i < name.length(); ++i)
+    g_waste_accumulator += name[i];
+}
+
+void CheckCorruptedStringArray(const mojo::Array<mojo::String>& string_array) {
+  for (size_t i = 0; i < string_array.size(); ++i)
+    CheckCorruptedString(string_array[i]);
+}
+
 // Base Provider implementation class. It's expected that tests subclass and
 // override the appropriate Provider functions. When test is done quit the
 // run_loop().
 class CppSideConnection : public js_to_cpp::CppSide {
  public:
   CppSideConnection() : run_loop_(NULL), js_side_(NULL) {
   }
   virtual ~CppSideConnection() {}
 
   void set_run_loop(base::RunLoop* run_loop) { run_loop_ = run_loop; }
@@ skipping 75 matching lines @@
 
   virtual void EchoResponse(const js_to_cpp::EchoArgs& arg1,
                             const js_to_cpp::EchoArgs& arg2) OVERRIDE {
     message_count_ += 1;
     CheckSampleEchoArgs(arg1);
     EXPECT_EQ(-1, arg2.si64());
     EXPECT_EQ(-1, arg2.si32());
     EXPECT_EQ(-1, arg2.si16());
     EXPECT_EQ(-1, arg2.si8());
     EXPECT_EQ(std::string("going"), arg2.name().To<std::string>());
+    CheckDataPipe(arg2.data_handle().get().value());
   }
 
   virtual void TestFinished() OVERRIDE {
     termination_seen_ = true;
     run_loop()->Quit();
   }
 
   bool DidSucceed() {
     return termination_seen_ && message_count_ == kExpectedMessageCount;
   }
@@ skipping 10 matching lines @@
  public:
   explicit BitFlipCppSideConnection() : termination_seen_(false) {}
   virtual ~BitFlipCppSideConnection() {}
 
   // js_to_cpp::CppSide:
   virtual void StartTest() OVERRIDE {
     AllocationScope scope;
     js_side_->BitFlip(BuildSampleEchoArgs());
   }
 
-  virtual void BitFlipResponse(const js_to_cpp::EchoArgs& arg1) OVERRIDE {
-    // TODO(tsepez): How to check, may be corrupt in various ways.
+  virtual void BitFlipResponse(const js_to_cpp::EchoArgs& arg) OVERRIDE {
+    if (arg.is_null())
+      return;
+    CheckCorruptedString(arg.name());
+    CheckCorruptedStringArray(arg.string_array());
+    if (arg.data_handle().is_valid())
+      CheckDataPipe(arg.data_handle().get().value());
   }
 
   virtual void TestFinished() OVERRIDE {
     termination_seen_ = true;
     run_loop()->Quit();
   }
 
   bool DidSucceed() {
     return termination_seen_;
   }
@@ skipping 60 matching lines @@
   if (IsRunningOnIsolatedBot())
     return;
 
   BitFlipCppSideConnection cpp_side_connection;
   RunTest("mojo/apps/js/test/js_to_cpp_unittest", &cpp_side_connection);
   EXPECT_TRUE(cpp_side_connection.DidSucceed());
 }
 
 }  // namespace js
 }  // namespace mojo