Mojo JS bindings: fix the unittests.

mojo/public/js/validation_unittests.js

 // 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.
 
 define([
     "console",
     "file",
     "gin/test/expect",
     "mojo/public/interfaces/bindings/tests/validation_test_interfaces.mojom",
     "mojo/public/js/buffer",
@@ skipping 162 matching lines @@
       testEmptyInput();
       testBlankInput();
       testHandles();
       testAnchors();
     } catch (e) {
       return e.toString();
     }
     return null;
   }
 
-  function getMessageTestFiles(key) {
+  function getMessageTestFiles(prefix) {
     var sourceRoot = file.getSourceRootDirectory();
     expect(sourceRoot).not.toBeNull();
 
     var testDir = sourceRoot +
       "/mojo/public/interfaces/bindings/tests/data/validation/";
     var testFiles = file.getFilesInDirectory(testDir);
     expect(testFiles).not.toBeNull();
     expect(testFiles.length).toBeGreaterThan(0);
 
     // The matching ".data" pathnames with the extension removed.
     return testFiles.filter(function(s) {
-      return s.substr(-5) == ".data";
+      return s.substr(-5) == ".data" && s.indexOf(prefix) == 0;
     }).map(function(s) {
       return testDir + s.slice(0, -5);
-    }).filter(function(s) {
-      return s.indexOf(key) != -1;
     });
   }
 
   function readTestMessage(filename) {
     var contents = file.readFileToString(filename + ".data");
     expect(contents).not.toBeNull();
     return parser.parseTestMessage(contents);
   }
 
   function readTestExpected(filename) {
     var contents = file.readFileToString(filename + ".expected");
     expect(contents).not.toBeNull();
     return contents.trim();
   }
 
   function checkValidationResult(testFile, err) {
     var actualResult = (err === noError) ? "PASS" : err;
     var expectedResult = readTestExpected(testFile);
     if (actualResult != expectedResult)
       console.log("[Test message validation failed: " + testFile + " ]");
     expect(actualResult).toEqual(expectedResult);
   }
 
-  function testMessageValidation(key, filters) {
-    var testFiles = getMessageTestFiles(key);
+  function testMessageValidation(prefix, filters) {
+    var testFiles = getMessageTestFiles(prefix);
     expect(testFiles.length).toBeGreaterThan(0);
 
     for (var i = 0; i < testFiles.length; i++) {
       // TODO(hansmuller) Temporarily skipping array pointer overflow tests
       // because JS numbers are limited to 53 bits.
       // TODO(yzshen) Skipping struct versioning tests (tests with "mthd11"
       // in the name) because the feature is not supported in JS yet.
       // TODO(rudominer): Temporarily skipping 'no-such-method',
       // 'invalid_request_flags', and 'invalid_response_flags' until additional
       // logic in *RequestValidator and *ResponseValidator is ported from
@@ skipping 18 matching lines @@
 
       checkValidationResult(testFiles[i], err);
     }
   }
 
   function testConformanceMessageValidation() {
     testMessageValidation("conformance_", [
         testInterface.ConformanceTestInterface.validateRequest]);
   }
 
-  function testIntegratedMessageValidation(testFilesPattern) {
+  function testBoundsCheckMessageValidation() {
+    testMessageValidation("boundscheck_", [
+        testInterface.BoundsCheckTestInterface.validateRequest]);
+  }
+
+  function testResponseConformanceMessageValidation() {
+    testMessageValidation("resp_conformance_", [
+        testInterface.ConformanceTestInterface.validateResponse]);
+  }
+
+  function testResponseBoundsCheckMessageValidation() {
+    testMessageValidation("resp_boundscheck_", [
+        testInterface.BoundsCheckTestInterface.validateResponse]);
+  }
+
+  function testIntegratedMessageValidation(testFilesPattern,
+                                           localFactory,
+                                           remoteFactory) {
     var testFiles = getMessageTestFiles(testFilesPattern);
     expect(testFiles.length).toBeGreaterThan(0);
 
+    var testMessagePipe = new core.createMessagePipe();
+    expect(testMessagePipe.result).toBe(core.RESULT_OK);
+    var testConnection = new connection.TestConnection(
+        testMessagePipe.handle1, localFactory, remoteFactory);
+
     for (var i = 0; i < testFiles.length; i++) {
       var testMessage = readTestMessage(testFiles[i]);
       var handles = new Array(testMessage.handleCount);
-      var testMessagePipe = new core.createMessagePipe();
-      expect(testMessagePipe.result).toBe(core.RESULT_OK);
 
       var writeMessageValue = core.writeMessage(
           testMessagePipe.handle0,
           new Uint8Array(testMessage.buffer.arrayBuffer),
           new Array(testMessage.handleCount),
           core.WRITE_MESSAGE_FLAG_NONE);
       expect(writeMessageValue).toBe(core.RESULT_OK);
 
-      var testConnection = new connection.TestConnection(
-          testMessagePipe.handle1,
-          testInterface.IntegrationTestInterface.stubClass,
-          testInterface.IntegrationTestInterface.proxyClass);
-
       var validationError = noError;
       testConnection.router_.validationErrorHandler = function(err) {
         validationError = err;
       }
 
-      testConnection.router_.connector_.deliverMessage();
+      testConnection.router_.connector_.waitForNextMessage();
       checkValidationResult(testFiles[i], validationError);
+    }
 
-      testConnection.close();
-      expect(core.close(testMessagePipe.handle0)).toBe(core.RESULT_OK);
-    }
+    testConnection.close();
+    expect(core.close(testMessagePipe.handle0)).toBe(core.RESULT_OK);
   }
 
   function testIntegratedMessageHeaderValidation() {
-    testIntegratedMessageValidation("integration_msghdr");
+    testIntegratedMessageValidation(
+        "integration_msghdr",
+        testInterface.IntegrationTestInterface.stubClass,
+        undefined);
+    testIntegratedMessageValidation(
+        "integration_msghdr",
+        undefined,
+        testInterface.IntegrationTestInterface.proxyClass);
   }
 
   function testIntegratedRequestMessageValidation() {
-    testIntegratedMessageValidation("integration_intf_rqst");
+    testIntegratedMessageValidation(
+        "integration_intf_rqst",
+        testInterface.IntegrationTestInterface.stubClass,
+        undefined);
   }
 
   function testIntegratedResponseMessageValidation() {
-    testIntegratedMessageValidation("integration_intf_resp");
+    testIntegratedMessageValidation(
+        "integration_intf_resp",
+        undefined,
+        testInterface.IntegrationTestInterface.proxyClass);
   }
 
   expect(checkTestMessageParser()).toBeNull();
   testConformanceMessageValidation();
+  testBoundsCheckMessageValidation();
+  testResponseConformanceMessageValidation();
+  testResponseBoundsCheckMessageValidation();
   testIntegratedMessageHeaderValidation();
   testIntegratedResponseMessageValidation();
   testIntegratedRequestMessageValidation();
+
   this.result = "PASS";
 });