Support [handles] in validation test input format and add handle-related 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 <string>
 #include <vector>
 
@@ skipping 19 matching lines @@
 
 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));
   memcpy(&(*data_vector)[pos], &data, sizeof(T));
 }
 
 bool TestInputParser(const std::string& input,
                      bool expected_result,
-                     const std::vector<uint8_t>& expected_parsed_input) {
-  std::vector<uint8_t> parsed_input;
+                     const std::vector<uint8_t>& expected_data,
+                     size_t expected_num_handles) {
+  std::vector<uint8_t> data;
+  size_t num_handles;
   std::string error_message;
 
-  bool result = ParseValidationTestInput(input, &parsed_input, &error_message);
+  bool result = ParseValidationTestInput(input, &data, &num_handles,
+                                         &error_message);
   if (expected_result) {
     if (result && error_message.empty() &&
-        expected_parsed_input == parsed_input) {
+        expected_data == data && expected_num_handles == num_handles) {
       return true;
     }
 
     // Compare with an empty string instead of checking |error_message.empty()|,
     // so that the message will be printed out if the two are not equal.
     EXPECT_EQ(std::string(), error_message);
-    EXPECT_EQ(expected_parsed_input, parsed_input);
+    EXPECT_EQ(expected_data, data);
+    EXPECT_EQ(expected_num_handles, num_handles);
     return false;
   }
 
   EXPECT_FALSE(error_message.empty());
   return !result && !error_message.empty();
 }
 
 std::vector<std::string> GetMatchingTests(const std::vector<std::string>& names,
                                           const std::string& prefix) {
   const std::string suffix = ".data";
@@ skipping 20 matching lines @@
     fclose(fp);
     return true;
   }
   fseek(fp, 0, SEEK_SET);
   result->resize(size);
   size_t size_read = fread(&result->at(0), 1, size, fp);
   fclose(fp);
   return size == size_read;
 }
 
-bool ReadAndParseDataFile(const std::string& path, std::vector<uint8_t>* data) {
+bool ReadAndParseDataFile(const std::string& path,
+                          std::vector<uint8_t>* data,
+                          size_t* num_handles) {
   std::string input;
   if (!ReadFile(path, &input))
     return false;
 
   std::string error_message;
-  if (!ParseValidationTestInput(input, data, &error_message)) {
+  if (!ParseValidationTestInput(input, data, num_handles, &error_message)) {
     ADD_FAILURE() << error_message;
     return false;
   }
 
   return true;
 }
 
 bool ReadResultFile(const std::string& path, std::string* result) {
   if (!ReadFile(path, result))
     return false;
@@ skipping 15 matching lines @@
 std::string GetPath(const std::string& root, const std::string& suffix) {
   return "mojo/public/interfaces/bindings/tests/data/validation/" +
       root + suffix;
 }
 
 // |message| should be a newly created object.
 bool ReadTestCase(const std::string& test,
                   Message* message,
                   std::string* expected) {
   std::vector<uint8_t> data;
-  if (!ReadAndParseDataFile(GetPath(test, ".data"), &data) ||
+  size_t num_handles;
+  if (!ReadAndParseDataFile(GetPath(test, ".data"), &data, &num_handles) ||
       !ReadResultFile(GetPath(test, ".expected"), expected)) {
     return false;
   }
 
   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.
+  message->mutable_handles()->resize(num_handles);
 
   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);
 
@@ skipping 115 matching lines @@
     // 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.
     std::string input;
     std::vector<uint8_t> expected;
 
-    EXPECT_TRUE(TestInputParser(input, true, expected));
+    EXPECT_TRUE(TestInputParser(input, true, expected, 0));
   }
   {
     // Test input that only consists of comments and whitespaces.
     std::string input = "    \t  // hello world \n\r \t// the answer is 42   ";
     std::vector<uint8_t> expected;
 
-    EXPECT_TRUE(TestInputParser(input, true, expected));
+    EXPECT_TRUE(TestInputParser(input, true, expected, 0));
   }
   {
     std::string input = "[u1]0x10// hello world !! \n\r  \t [u2]65535 \n"
                         "[u4]65536 [u8]0xFFFFFFFFFFFFFFFF 0 0Xff";
     std::vector<uint8_t> expected;
     Append(&expected, static_cast<uint8_t>(0x10));
     Append(&expected, static_cast<uint16_t>(65535));
     Append(&expected, static_cast<uint32_t>(65536));
     Append(&expected, static_cast<uint64_t>(0xffffffffffffffff));
     Append(&expected, static_cast<uint8_t>(0));
     Append(&expected, static_cast<uint8_t>(0xff));
 
-    EXPECT_TRUE(TestInputParser(input, true, expected));
+    EXPECT_TRUE(TestInputParser(input, true, expected, 0));
   }
   {
     std::string input = "[s8]-0x800 [s1]-128\t[s2]+0 [s4]-40";
     std::vector<uint8_t> expected;
     Append(&expected, -static_cast<int64_t>(0x800));
     Append(&expected, static_cast<int8_t>(-128));
     Append(&expected, static_cast<int16_t>(0));
     Append(&expected, static_cast<int32_t>(-40));
 
-    EXPECT_TRUE(TestInputParser(input, true, expected));
+    EXPECT_TRUE(TestInputParser(input, true, expected, 0));
   }
   {
     std::string input = "[b]00001011 [b]10000000  // hello world\r [b]00000000";
     std::vector<uint8_t> expected;
     Append(&expected, static_cast<uint8_t>(11));
     Append(&expected, static_cast<uint8_t>(128));
     Append(&expected, static_cast<uint8_t>(0));
 
-    EXPECT_TRUE(TestInputParser(input, true, expected));
+    EXPECT_TRUE(TestInputParser(input, true, expected, 0));
   }
   {
     std::string input = "[f]+.3e9 [d]-10.03";
     std::vector<uint8_t> expected;
     Append(&expected, +.3e9f);
     Append(&expected, -10.03);
 
-    EXPECT_TRUE(TestInputParser(input, true, expected));
+    EXPECT_TRUE(TestInputParser(input, true, expected, 0));
   }
   {
     std::string input = "[dist4]foo 0 [dist8]bar 0 [anchr]foo [anchr]bar";
     std::vector<uint8_t> expected;
     Append(&expected, static_cast<uint32_t>(14));
     Append(&expected, static_cast<uint8_t>(0));
     Append(&expected, static_cast<uint64_t>(9));
     Append(&expected, static_cast<uint8_t>(0));
 
-    EXPECT_TRUE(TestInputParser(input, true, expected));
+    EXPECT_TRUE(TestInputParser(input, true, expected, 0));
+  }
+  {
+    std::string input = "// This message has handles! \n[handles]50 [u8]2";
+    std::vector<uint8_t> expected;
+    Append(&expected, static_cast<uint64_t>(2));
+
+    EXPECT_TRUE(TestInputParser(input, true, expected, 50));
   }
 
   // Test some failure cases.
   {
     const char* error_inputs[] = {
       "/ hello world",
       "[u1]x",
+      "[u2]-1000",
       "[u1]0x100",
       "[s2]-0x8001",
       "[b]1",
       "[b]1111111k",
       "[dist4]unmatched",
       "[anchr]hello [dist8]hello",
+      "0 [handles]50",
       NULL
     };
 
     for (size_t i = 0; error_inputs[i]; ++i) {
       std::vector<uint8_t> expected;
-      if (!TestInputParser(error_inputs[i], false, expected))
+      if (!TestInputParser(error_inputs[i], false, expected, 0))
         ADD_FAILURE() << "Unexpected test result for: " << error_inputs[i];
     }
   }
 }
 
 TEST(ValidationTest, Conformance) {
   DummyMessageReceiver dummy_receiver;
   mojo::internal::FilterChain validators(&dummy_receiver);
   validators.Append<mojo::internal::MessageHeaderValidator>();
   validators.Append<ConformanceTestInterface::RequestValidator_>();
 
-  // TODO(yzshen): add more conformance tests.
   RunValidationTests("conformance_", validators.GetHead());
 }
 
 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_
 
@@ skipping 17 matching lines @@
   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