• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5
6[JavaPackage="org.chromium.mojo.bindings.test.mojom.mojo"]
7module mojo.test;
8
9struct StructA {
10  uint64 i;
11};
12
13struct StructB {
14  StructA struct_a;
15};
16
17struct StructC {
18  array<uint8> data;
19};
20
21struct StructD {
22  array<handle<message_pipe>> message_pipes;
23};
24
25struct StructE {
26  StructD struct_d;
27  handle<data_pipe_consumer> data_pipe_consumer;
28};
29
30struct StructF {
31  array<uint8, 3> fixed_size_array;
32};
33
34struct StructG {
35  int32 i;
36  [MinVersion=1]
37  StructA? struct_a;
38  [MinVersion=3]
39  string? str;
40  [MinVersion=3]
41  bool b;
42};
43
44interface InterfaceA {
45};
46
47enum EnumA {
48  ENUM_A_0,
49  ENUM_A_1
50};
51
52[Extensible]
53enum EnumB {
54  ENUM_B_0,
55  ENUM_B_1,
56  ENUM_B_2
57};
58
59// A non-extensible enum with no values is valid, but about as useless as
60// you would expect: it will fail validation for all values.
61enum EmptyEnum {};
62
63[Extensible]
64enum ExtensibleEmptyEnum {};
65
66union UnionA {
67  StructA struct_a;
68  bool b;
69};
70
71// This interface is used for testing bounds-checking in the mojom
72// binding code. If you add a method please update the files
73// ./data/validation/boundscheck_*. If you add a response please update
74// ./data/validation/resp_boundscheck_*.
75interface BoundsCheckTestInterface {
76  Method0(uint8 param0) => (uint8 param0);
77  Method1(uint8 param0);
78};
79
80interface ConformanceTestInterface {
81  Method0(float param0);
82  Method1(StructA param0);
83  Method2(StructB param0, StructA param1);
84  Method3(array<bool> param0);
85  Method4(StructC param0, array<uint8> param1);
86  Method5(StructE param0, handle<data_pipe_producer> param1);
87  Method6(array<array<uint8>> param0);
88  Method7(StructF param0, array<array<uint8, 3>?, 2> param1);
89  Method8(array<array<string>?> param0);
90  Method9(array<array<handle?>>? param0);
91  Method10(map<string, uint8> param0);
92  Method11(StructG param0);
93  Method12(float param0) => (float param0);
94  Method13(InterfaceA? param0, uint32 param1, InterfaceA? param2);
95  Method14(EnumA param0, EnumB param1);
96  Method15(array<EnumA>? param0, array<EnumB>? param1);
97  Method16(map<EnumA, EnumA>? param0);
98  Method17(array<InterfaceA> param0);
99  Method18(UnionA? param0);
100  Method19(Recursive recursive);
101  Method20(map<StructB, uint8> param0);
102  Method21(ExtensibleEmptyEnum param0);
103  Method22(EmptyEnum param0);
104};
105
106struct BasicStruct {
107  int32 a;
108};
109
110interface IntegrationTestInterface {
111  Method0(BasicStruct param0) => (array<uint8> param0);
112};
113
114// An enum generates a enum-value validation function, so we want to test it.
115// E.g., valid enum values for this enum should be:  -3, 0, 1, 10
116enum BasicEnum {
117  A,
118  B,
119  C = A,
120  D = -3,
121  E = 0xA
122};
123
124// The enum validation function should be generated within the scope of this
125// struct.
126struct StructWithEnum {
127  enum EnumWithin {
128    A, B, C, D
129  };
130};
131
132// This is used to test that deeply recursive structures don't blow the stack.
133struct Recursive {
134  Recursive? recursive;
135};
136