1 files changed, 135 insertions, 0 deletions
diff --git a/mojo/public/interfaces/bindings/tests/validation_test_interfaces.mojom b/mojo/public/interfaces/bindings/tests/validation_test_interfaces.mojom
new file mode 100644
index 0000000000..ab69045e53
--- /dev/null
+++ b/mojo/public/interfaces/bindings/tests/validation_test_interfaces.mojom
@@ -0,0 +1,135 @@
+// 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.
+
+
+[JavaPackage="org.chromium.mojo.bindings.test.mojom.mojo"]
+module mojo.test;
+
+struct StructA {
+  uint64 i;
+};
+
+struct StructB {
+  StructA struct_a;
+};
+
+struct StructC {
+  array<uint8> data;
+};
+
+struct StructD {
+  array<handle<message_pipe>> message_pipes;
+};
+
+struct StructE {
+  StructD struct_d;
+  handle<data_pipe_consumer> data_pipe_consumer;
+};
+
+struct StructF {
+  array<uint8, 3> fixed_size_array;
+};
+
+struct StructG {
+  int32 i;
+  [MinVersion=1]
+  StructA? struct_a;
+  [MinVersion=3]
+  string? str;
+  [MinVersion=3]
+  bool b;
+};
+
+interface InterfaceA {
+};
+
+enum EnumA {
+  ENUM_A_0,
+  ENUM_A_1
+};
+
+[Extensible]
+enum EnumB {
+  ENUM_B_0,
+  ENUM_B_1,
+  ENUM_B_2
+};
+
+// A non-extensible enum with no values is valid, but about as useless as
+// you would expect: it will fail validation for all values.
+enum EmptyEnum {};
+
+[Extensible]
+enum ExtensibleEmptyEnum {};
+
+union UnionA {
+  StructA struct_a;
+  bool b;
+};
+
+// This interface is used for testing bounds-checking in the mojom
+// binding code. If you add a method please update the files
+// ./data/validation/boundscheck_*. If you add a response please update
+// ./data/validation/resp_boundscheck_*.
+interface BoundsCheckTestInterface {
+  Method0(uint8 param0) => (uint8 param0);
+  Method1(uint8 param0);
+};
+
+interface ConformanceTestInterface {
+  Method0(float param0);
+  Method1(StructA param0);
+  Method2(StructB param0, StructA param1);
+  Method3(array<bool> param0);
+  Method4(StructC param0, array<uint8> param1);
+  Method5(StructE param0, handle<data_pipe_producer> param1);
+  Method6(array<array<uint8>> param0);
+  Method7(StructF param0, array<array<uint8, 3>?, 2> param1);
+  Method8(array<array<string>?> param0);
+  Method9(array<array<handle?>>? param0);
+  Method10(map<string, uint8> param0);
+  Method11(StructG param0);
+  Method12(float param0) => (float param0);
+  Method13(InterfaceA? param0, uint32 param1, InterfaceA? param2);
+  Method14(EnumA param0, EnumB param1);
+  Method15(array<EnumA>? param0, array<EnumB>? param1);
+  Method16(map<EnumA, EnumA>? param0);
+  Method17(array<InterfaceA> param0);
+  Method18(UnionA? param0);
+  Method19(Recursive recursive);
+  Method20(map<StructB, uint8> param0);
+  Method21(ExtensibleEmptyEnum param0);
+  Method22(EmptyEnum param0);
+};
+
+struct BasicStruct {
+  int32 a;
+};
+
+interface IntegrationTestInterface {
+  Method0(BasicStruct param0) => (array<uint8> param0);
+};
+
+// An enum generates a enum-value validation function, so we want to test it.
+// E.g., valid enum values for this enum should be:  -3, 0, 1, 10
+enum BasicEnum {
+  A,
+  B,
+  C = A,
+  D = -3,
+  E = 0xA
+};
+
+// The enum validation function should be generated within the scope of this
+// struct.
+struct StructWithEnum {
+  enum EnumWithin {
+    A, B, C, D
+  };
+};
+
+// This is used to test that deeply recursive structures don't blow the stack.
+struct Recursive {
+  Recursive? recursive;
+};