Mojo message validation tests: add integration tests and move existing conformance tests.

mojo/public/cpp/bindings/tests/validation_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 <stdio.h>
 
 #include <algorithm>
-#include <sstream>
 #include <string>
 #include <vector>
 
+#include "mojo/public/c/system/macros.h"
+#include "mojo/public/cpp/bindings/interface_impl.h"
+#include "mojo/public/cpp/bindings/interface_ptr.h"
+#include "mojo/public/cpp/bindings/lib/connector.h"
+#include "mojo/public/cpp/bindings/lib/filter_chain.h"
 #include "mojo/public/cpp/bindings/lib/message_header_validator.h"
+#include "mojo/public/cpp/bindings/lib/router.h"
 #include "mojo/public/cpp/bindings/lib/validation_errors.h"
+#include "mojo/public/cpp/bindings/message.h"
 #include "mojo/public/cpp/bindings/tests/validation_test_input_parser.h"
+#include "mojo/public/cpp/environment/environment.h"
+#include "mojo/public/cpp/system/core.h"
 #include "mojo/public/cpp/test_support/test_support.h"
+#include "mojo/public/cpp/utility/run_loop.h"
+#include "mojo/public/interfaces/bindings/tests/validation_test_interfaces.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace test {
 namespace {
 
 template <typename T>
 void Append(std::vector<uint8_t>* data_vector, T data) {
   size_t pos = data_vector->size();
   data_vector->resize(pos + sizeof(T));
@@ skipping 83 matching lines @@
   size_t pos = result->find_last_not_of('\n');
   if (pos == std::string::npos)
     result->clear();
   else
     result->resize(pos + 1);
 
   return true;
 }
 
 std::string GetPath(const std::string& root, const std::string& suffix) {
-  return "mojo/public/interfaces/bindings/tests/data/" + root + suffix;
+  return "mojo/public/interfaces/bindings/tests/data/validation/" +
+      root + suffix;
 }
 
-void RunValidationTest(const std::string& root, std::string (*func)(Message*)) {
+// |message| should be a newly created object.
+bool ReadTestCase(const std::string& test,
+                  Message* message,
+                  std::string* expected) {
   std::vector<uint8_t> data;
-  ASSERT_TRUE(ReadAndParseDataFile(GetPath(root, ".data"), &data));
+  if (!ReadAndParseDataFile(GetPath(test, ".data"), &data) ||
+      !ReadResultFile(GetPath(test, ".expected"), expected)) {
+    return false;
+  }
 
-  std::string expected;
-  ASSERT_TRUE(ReadResultFile(GetPath(root, ".expected"), &expected));
+  message->AllocUninitializedData(static_cast<uint32_t>(data.size()));
+  if (!data.empty())
+    memcpy(message->mutable_data(), &data[0], data.size());
 
-  Message message;
-  message.AllocUninitializedData(static_cast<uint32_t>(data.size()));
-  if (!data.empty())
-    memcpy(message.mutable_data(), &data[0], data.size());
+  // TODO(yzshen): add support to specify the number of handles associated with
+  // the message.
 
-  std::string result = func(&message);
-  EXPECT_EQ(expected, result) << "failed test: " << root;
+  return true;
+}
+
+void RunValidationTests(const std::string& prefix,
+                        MessageReceiver* test_message_receiver) {
+  std::vector<std::string> names =
+      EnumerateSourceRootRelativeDirectory(GetPath("", ""));
+  std::vector<std::string> tests = GetMatchingTests(names, prefix);
+
+  for (size_t i = 0; i < tests.size(); ++i) {
+    Message message;
+    std::string expected;
+    ASSERT_TRUE(ReadTestCase(tests[i], &message, &expected));
+
+    std::string result;
+    mojo::internal::ValidationErrorObserverForTesting observer;
+    bool unused MOJO_ALLOW_UNUSED = test_message_receiver->Accept(&message);
+    if (observer.last_error() == mojo::internal::VALIDATION_ERROR_NONE)
+      result = "PASS";
+    else
+      result = mojo::internal::ValidationErrorToString(observer.last_error());
+
+    EXPECT_EQ(expected, result) << "failed test: " << tests[i];
+  }
 }
 
 class DummyMessageReceiver : public MessageReceiver {
  public:
   virtual bool Accept(Message* message) MOJO_OVERRIDE {
     return true;  // Any message is OK.
   }
 };
 
-std::string DumpMessageHeader(Message* message) {
-  internal::ValidationErrorObserverForTesting observer;
-  DummyMessageReceiver not_reached_receiver;
-  internal::MessageHeaderValidator validator(&not_reached_receiver);
-  bool rv = validator.Accept(message);
-  if (!rv) {
-    EXPECT_NE(internal::VALIDATION_ERROR_NONE, observer.last_error());
-    return internal::ValidationErrorToString(observer.last_error());
+class ValidationIntegrationTest : public testing::Test {
+ public:
+  ValidationIntegrationTest() : test_message_receiver_(NULL) {
   }
 
-  std::ostringstream os;
-  os << "num_bytes: " << message->header()->num_bytes << "\n"
-     << "num_fields: " << message->header()->num_fields << "\n"
-     << "name: " << message->header()->name << "\n"
-     << "flags: " << message->header()->flags;
-  return os.str();
-}
+  virtual ~ValidationIntegrationTest() {
+  }
+
+  virtual void SetUp() MOJO_OVERRIDE {
+    ScopedMessagePipeHandle tester_endpoint;
+    ASSERT_EQ(MOJO_RESULT_OK,
+              CreateMessagePipe(NULL, &tester_endpoint, &testee_endpoint_));
+    test_message_receiver_ =
+        new TestMessageReceiver(this, tester_endpoint.Pass());
+  }
+
+  virtual void TearDown() MOJO_OVERRIDE {
+    delete test_message_receiver_;
+    test_message_receiver_ = NULL;
+
+    // Make sure that the other end receives the OnConnectionError()
+    // notification.
+    PumpMessages();
+  }
+
+  MessageReceiver* test_message_receiver() {
+    return test_message_receiver_;
+  }
+
+  ScopedMessagePipeHandle testee_endpoint() {
+    return testee_endpoint_.Pass();
+  }
+
+ private:
+  class TestMessageReceiver : public MessageReceiver {
+   public:
+    TestMessageReceiver(ValidationIntegrationTest* owner,
+                        ScopedMessagePipeHandle handle)
+        : owner_(owner),
+          connector_(handle.Pass()) {
+    }
+    virtual ~TestMessageReceiver() {
+    }
+
+    virtual bool Accept(Message* message) MOJO_OVERRIDE {
+      bool rv = connector_.Accept(message);
+      owner_->PumpMessages();
+      return rv;
+    }
+
+   public:
+    ValidationIntegrationTest* owner_;
+    mojo::internal::Connector connector_;
+  };
+
+  void PumpMessages() {
+    loop_.RunUntilIdle();
+  }
+
+  Environment env_;
+  RunLoop loop_;
+  TestMessageReceiver* test_message_receiver_;
+  ScopedMessagePipeHandle testee_endpoint_;
+};
+
+class IntegrationTestInterface1Client : public IntegrationTestInterface1 {
+ public:
+  virtual ~IntegrationTestInterface1Client() {
+  }
+
+  virtual void Method0(BasicStructPtr param0) MOJO_OVERRIDE {
+  }
+};
+
+class IntegrationTestInterface1Impl
+    : public InterfaceImpl<IntegrationTestInterface1> {
+ public:
+  virtual ~IntegrationTestInterface1Impl() {
+  }
+
+  virtual void Method0(BasicStructPtr param0) MOJO_OVERRIDE {
+  }
+
+  virtual void OnConnectionError() MOJO_OVERRIDE {
+    delete this;
+  }
+};
 
 TEST(ValidationTest, InputParser) {
   {
     // The parser, as well as Append() defined above, assumes that this code is
     // running on a little-endian platform. Test whether that is true.
     uint16_t x = 1;
     ASSERT_EQ(1, *(reinterpret_cast<char*>(&x)));
   }
   {
     // Test empty input.
@@ skipping 75 matching lines @@
     };
 
     for (size_t i = 0; error_inputs[i]; ++i) {
       std::vector<uint8_t> expected;
       if (!TestInputParser(error_inputs[i], false, expected))
         ADD_FAILURE() << "Unexpected test result for: " << error_inputs[i];
     }
   }
 }
 
-TEST(ValidationTest, TestAll) {
-  std::vector<std::string> names =
-      EnumerateSourceRootRelativeDirectory(GetPath("", ""));
+TEST(ValidationTest, Conformance) {
+  DummyMessageReceiver dummy_receiver;
+  mojo::internal::FilterChain validators(&dummy_receiver);
+  validators.Append<mojo::internal::MessageHeaderValidator>();
+  validators.Append<ConformanceTestInterface::RequestValidator_>();
 
-  std::vector<std::string> header_tests =
-      GetMatchingTests(names, "validate_header_");
+  // TODO(yzshen): add more conformance tests.
+  RunValidationTests("conformance_", validators.GetHead());
+}
 
-  for (size_t i = 0; i < header_tests.size(); ++i)
-    RunValidationTest(header_tests[i], &DumpMessageHeader);
+TEST_F(ValidationIntegrationTest, InterfacePtr) {
+  // Test that InterfacePtr<X> applies the correct validators and they don't
+  // conflict with each other:
+  //   - MessageHeaderValidator
+  //   - X::Client::RequestValidator_
+  //   - X::ResponseValidator_
+
+  IntegrationTestInterface1Client interface1_client;
+  IntegrationTestInterface2Ptr interface2_ptr =
+      MakeProxy<IntegrationTestInterface2>(testee_endpoint().Pass());
+  interface2_ptr.set_client(&interface1_client);
+  interface2_ptr.internal_state()->router()->EnableTestingMode();
+
+  RunValidationTests("integration_", test_message_receiver());
+}
+
+TEST_F(ValidationIntegrationTest, InterfaceImpl) {
+  // Test that InterfaceImpl<X> applies the correct validators and they don't
+  // conflict with each other:
+  //   - MessageHeaderValidator
+  //   - X::RequestValidator_
+  //   - X::Client::ResponseValidator_
+
+  // |interface1_impl| will delete itself when the pipe is closed.
+  IntegrationTestInterface1Impl* interface1_impl =
+      BindToPipe(new IntegrationTestInterface1Impl(), testee_endpoint().Pass());
+  interface1_impl->internal_state()->router()->EnableTestingMode();
+
+  RunValidationTests("integration_", test_message_receiver());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace mojo