OLD | NEW |
| (Empty) |
1 // Copyright 2013 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 define([ | |
6 "console", | |
7 "mojo/edk/js/test/hexdump", | |
8 "gin/test/expect", | |
9 "mojo/public/interfaces/bindings/tests/sample_service.mojom", | |
10 "mojo/public/interfaces/bindings/tests/sample_import.mojom", | |
11 "mojo/public/interfaces/bindings/tests/sample_import2.mojom", | |
12 ], function(console, hexdump, expect, sample, imported, imported2) { | |
13 | |
14 var global = this; | |
15 | |
16 // Set this variable to true to print the binary message in hex. | |
17 var dumpMessageAsHex = false; | |
18 | |
19 function makeFoo() { | |
20 var bar = new sample.Bar(); | |
21 bar.alpha = 20; | |
22 bar.beta = 40; | |
23 bar.gamma = 60; | |
24 bar.type = sample.Bar.Type.VERTICAL; | |
25 | |
26 var extra_bars = new Array(3); | |
27 for (var i = 0; i < extra_bars.length; ++i) { | |
28 var base = i * 100; | |
29 var type = i % 2 ? | |
30 sample.Bar.Type.VERTICAL : sample.Bar.Type.HORIZONTAL; | |
31 extra_bars[i] = new sample.Bar(); | |
32 extra_bars[i].alpha = base; | |
33 extra_bars[i].beta = base + 20; | |
34 extra_bars[i].gamma = base + 40; | |
35 extra_bars[i].type = type; | |
36 } | |
37 | |
38 var data = new Array(10); | |
39 for (var i = 0; i < data.length; ++i) { | |
40 data[i] = data.length - i; | |
41 } | |
42 | |
43 var source = 0xFFFF; // Invent a dummy handle. | |
44 | |
45 var foo = new sample.Foo(); | |
46 foo.name = "foopy"; | |
47 foo.x = 1; | |
48 foo.y = 2; | |
49 foo.a = false; | |
50 foo.b = true; | |
51 foo.c = false; | |
52 foo.bar = bar; | |
53 foo.extra_bars = extra_bars; | |
54 foo.data = data; | |
55 foo.source = source; | |
56 return foo; | |
57 } | |
58 | |
59 // Check that the given |Foo| is identical to the one made by |MakeFoo()|. | |
60 function checkFoo(foo) { | |
61 expect(foo.name).toBe("foopy"); | |
62 expect(foo.x).toBe(1); | |
63 expect(foo.y).toBe(2); | |
64 expect(foo.a).toBeFalsy(); | |
65 expect(foo.b).toBeTruthy(); | |
66 expect(foo.c).toBeFalsy(); | |
67 expect(foo.bar.alpha).toBe(20); | |
68 expect(foo.bar.beta).toBe(40); | |
69 expect(foo.bar.gamma).toBe(60); | |
70 expect(foo.bar.type).toBe(sample.Bar.Type.VERTICAL); | |
71 | |
72 expect(foo.extra_bars.length).toBe(3); | |
73 for (var i = 0; i < foo.extra_bars.length; ++i) { | |
74 var base = i * 100; | |
75 var type = i % 2 ? | |
76 sample.Bar.Type.VERTICAL : sample.Bar.Type.HORIZONTAL; | |
77 expect(foo.extra_bars[i].alpha).toBe(base); | |
78 expect(foo.extra_bars[i].beta).toBe(base + 20); | |
79 expect(foo.extra_bars[i].gamma).toBe(base + 40); | |
80 expect(foo.extra_bars[i].type).toBe(type); | |
81 } | |
82 | |
83 expect(foo.data.length).toBe(10); | |
84 for (var i = 0; i < foo.data.length; ++i) | |
85 expect(foo.data[i]).toBe(foo.data.length - i); | |
86 | |
87 expect(foo.source).toBe(0xFFFF); | |
88 } | |
89 | |
90 // Check that values are set to the defaults if we don't override them. | |
91 function checkDefaultValues() { | |
92 var bar = new sample.Bar(); | |
93 expect(bar.alpha).toBe(255); | |
94 expect(bar.type).toBe(sample.Bar.Type.VERTICAL); | |
95 | |
96 var foo = new sample.Foo(); | |
97 expect(foo.name).toBe("Fooby"); | |
98 expect(foo.a).toBeTruthy(); | |
99 expect(foo.data).toBeNull(); | |
100 | |
101 var defaults = new sample.DefaultsTest(); | |
102 expect(defaults.a0).toBe(-12); | |
103 expect(defaults.a1).toBe(sample.kTwelve); | |
104 expect(defaults.a2).toBe(1234); | |
105 expect(defaults.a3).toBe(34567); | |
106 expect(defaults.a4).toBe(123456); | |
107 expect(defaults.a5).toBe(3456789012); | |
108 expect(defaults.a6).toBe(-111111111111); | |
109 // JS doesn't have a 64 bit integer type so this is just checking that the | |
110 // expected and actual values have the same closest double value. | |
111 expect(defaults.a7).toBe(9999999999999999999); | |
112 expect(defaults.a8).toBe(0x12345); | |
113 expect(defaults.a9).toBe(-0x12345); | |
114 expect(defaults.a10).toBe(1234); | |
115 expect(defaults.a11).toBe(true); | |
116 expect(defaults.a12).toBe(false); | |
117 expect(defaults.a13).toBe(123.25); | |
118 expect(defaults.a14).toBe(1234567890.123); | |
119 expect(defaults.a15).toBe(1E10); | |
120 expect(defaults.a16).toBe(-1.2E+20); | |
121 expect(defaults.a17).toBe(1.23E-20); | |
122 expect(defaults.a20).toBe(sample.Bar.Type.BOTH); | |
123 expect(defaults.a21).toBeNull(); | |
124 expect(defaults.a22).toBeTruthy(); | |
125 expect(defaults.a22.shape).toBe(imported.Shape.RECTANGLE); | |
126 expect(defaults.a22.color).toBe(imported2.Color.BLACK); | |
127 expect(defaults.a21).toBeNull(); | |
128 expect(defaults.a23).toBe(0xFFFFFFFFFFFFFFFF); | |
129 expect(defaults.a24).toBe(0x123456789); | |
130 expect(defaults.a25).toBe(-0x123456789); | |
131 } | |
132 | |
133 function ServiceImpl() { | |
134 } | |
135 | |
136 ServiceImpl.prototype = Object.create(sample.Service.stubClass.prototype); | |
137 | |
138 ServiceImpl.prototype.frobinate = function(foo, baz, port) { | |
139 checkFoo(foo); | |
140 expect(baz).toBe(sample.Service.BazOptions.EXTRA); | |
141 expect(port).toBe(10); | |
142 global.result = "PASS"; | |
143 }; | |
144 | |
145 function SimpleMessageReceiver() { | |
146 } | |
147 | |
148 SimpleMessageReceiver.prototype.accept = function(message) { | |
149 if (dumpMessageAsHex) { | |
150 var uint8Array = new Uint8Array(message.buffer.arrayBuffer); | |
151 console.log(hexdump.dumpArray(uint8Array)); | |
152 } | |
153 // Imagine some IPC happened here. | |
154 var serviceImpl = new ServiceImpl(); | |
155 serviceImpl.accept(message); | |
156 }; | |
157 | |
158 var receiver = new SimpleMessageReceiver(); | |
159 var serviceProxy = new sample.Service.proxyClass(receiver); | |
160 | |
161 checkDefaultValues(); | |
162 | |
163 var foo = makeFoo(); | |
164 checkFoo(foo); | |
165 | |
166 var port = 10; | |
167 serviceProxy.frobinate(foo, sample.Service.BazOptions.EXTRA, port); | |
168 }); | |
OLD | NEW |