OLD | NEW |
| (Empty) |
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 define([ | |
6 "gin/test/expect", | |
7 "mojo/public/js/codec", | |
8 "mojo/public/interfaces/bindings/tests/rect.mojom", | |
9 "mojo/public/interfaces/bindings/tests/sample_service.mojom", | |
10 "mojo/public/interfaces/bindings/tests/test_structs.mojom", | |
11 ], function(expect, codec, rect, sample, structs) { | |
12 testBar(); | |
13 testFoo(); | |
14 testNamedRegion(); | |
15 testSingleBooleanStruct(); | |
16 testTypes(); | |
17 testAlign(); | |
18 testUtf8(); | |
19 testTypedPointerValidation(); | |
20 this.result = "PASS"; | |
21 | |
22 function testBar() { | |
23 var bar = new sample.Bar(); | |
24 bar.alpha = 1; | |
25 bar.beta = 2; | |
26 bar.gamma = 3; | |
27 bar.type = 0x08070605; | |
28 bar.extraProperty = "banana"; | |
29 | |
30 var messageName = 42; | |
31 var payloadSize = sample.Bar.encodedSize; | |
32 | |
33 var builder = new codec.MessageBuilder(messageName, payloadSize); | |
34 builder.encodeStruct(sample.Bar, bar); | |
35 | |
36 var message = builder.finish(); | |
37 | |
38 var expectedMemory = new Uint8Array([ | |
39 24, 0, 0, 0, | |
40 0, 0, 0, 0, | |
41 0, 0, 0, 0, | |
42 42, 0, 0, 0, | |
43 0, 0, 0, 0, | |
44 0, 0, 0, 0, | |
45 | |
46 16, 0, 0, 0, | |
47 0, 0, 0, 0, | |
48 | |
49 1, 2, 3, 0, | |
50 5, 6, 7, 8, | |
51 ]); | |
52 | |
53 var actualMemory = new Uint8Array(message.buffer.arrayBuffer); | |
54 expect(actualMemory).toEqual(expectedMemory); | |
55 | |
56 var reader = new codec.MessageReader(message); | |
57 | |
58 expect(reader.payloadSize).toBe(payloadSize); | |
59 expect(reader.messageName).toBe(messageName); | |
60 | |
61 var bar2 = reader.decodeStruct(sample.Bar); | |
62 | |
63 expect(bar2.alpha).toBe(bar.alpha); | |
64 expect(bar2.beta).toBe(bar.beta); | |
65 expect(bar2.gamma).toBe(bar.gamma); | |
66 expect("extraProperty" in bar2).toBeFalsy(); | |
67 } | |
68 | |
69 function testFoo() { | |
70 var foo = new sample.Foo(); | |
71 foo.x = 0x212B4D5; | |
72 foo.y = 0x16E93; | |
73 foo.a = 1; | |
74 foo.b = 0; | |
75 foo.c = 3; // This will get truncated to one bit. | |
76 foo.bar = new sample.Bar(); | |
77 foo.bar.alpha = 91; | |
78 foo.bar.beta = 82; | |
79 foo.bar.gamma = 73; | |
80 foo.data = [ | |
81 4, 5, 6, 7, 8, | |
82 ]; | |
83 foo.extra_bars = [ | |
84 new sample.Bar(), new sample.Bar(), new sample.Bar(), | |
85 ]; | |
86 for (var i = 0; i < foo.extra_bars.length; ++i) { | |
87 foo.extra_bars[i].alpha = 1 * i; | |
88 foo.extra_bars[i].beta = 2 * i; | |
89 foo.extra_bars[i].gamma = 3 * i; | |
90 } | |
91 foo.name = "I am a banana"; | |
92 // This is supposed to be a handle, but we fake it with an integer. | |
93 foo.source = 23423782; | |
94 foo.array_of_array_of_bools = [ | |
95 [true], [false, true] | |
96 ]; | |
97 foo.array_of_bools = [ | |
98 true, false, true, false, true, false, true, true | |
99 ]; | |
100 | |
101 | |
102 var messageName = 31; | |
103 var payloadSize = 304; | |
104 | |
105 var builder = new codec.MessageBuilder(messageName, payloadSize); | |
106 builder.encodeStruct(sample.Foo, foo); | |
107 | |
108 var message = builder.finish(); | |
109 | |
110 var expectedMemory = new Uint8Array([ | |
111 /* 0: */ 24, 0, 0, 0, 0, 0, 0, 0, | |
112 /* 8: */ 0, 0, 0, 0, 31, 0, 0, 0, | |
113 /* 16: */ 0, 0, 0, 0, 0, 0, 0, 0, | |
114 /* 24: */ 96, 0, 0, 0, 0, 0, 0, 0, | |
115 /* 32: */ 0xD5, 0xB4, 0x12, 0x02, 0x93, 0x6E, 0x01, 0, | |
116 /* 40: */ 5, 0, 0, 0, 0, 0, 0, 0, | |
117 /* 48: */ 72, 0, 0, 0, 0, 0, 0, 0, | |
118 ]); | |
119 // TODO(abarth): Test more of the message's raw memory. | |
120 var actualMemory = new Uint8Array(message.buffer.arrayBuffer, | |
121 0, expectedMemory.length); | |
122 expect(actualMemory).toEqual(expectedMemory); | |
123 | |
124 var expectedHandles = [ | |
125 23423782, | |
126 ]; | |
127 | |
128 expect(message.handles).toEqual(expectedHandles); | |
129 | |
130 var reader = new codec.MessageReader(message); | |
131 | |
132 expect(reader.payloadSize).toBe(payloadSize); | |
133 expect(reader.messageName).toBe(messageName); | |
134 | |
135 var foo2 = reader.decodeStruct(sample.Foo); | |
136 | |
137 expect(foo2.x).toBe(foo.x); | |
138 expect(foo2.y).toBe(foo.y); | |
139 | |
140 expect(foo2.a).toBe(foo.a & 1 ? true : false); | |
141 expect(foo2.b).toBe(foo.b & 1 ? true : false); | |
142 expect(foo2.c).toBe(foo.c & 1 ? true : false); | |
143 | |
144 expect(foo2.bar).toEqual(foo.bar); | |
145 expect(foo2.data).toEqual(foo.data); | |
146 | |
147 expect(foo2.extra_bars).toEqual(foo.extra_bars); | |
148 expect(foo2.name).toBe(foo.name); | |
149 expect(foo2.source).toEqual(foo.source); | |
150 | |
151 expect(foo2.array_of_bools).toEqual(foo.array_of_bools); | |
152 } | |
153 | |
154 function createRect(x, y, width, height) { | |
155 var r = new rect.Rect(); | |
156 r.x = x; | |
157 r.y = y; | |
158 r.width = width; | |
159 r.height = height; | |
160 return r; | |
161 } | |
162 | |
163 // Verify that the references to the imported Rect type in test_structs.mojom | |
164 // are generated correctly. | |
165 function testNamedRegion() { | |
166 var r = new structs.NamedRegion(); | |
167 r.name = "rectangle"; | |
168 r.rects = new Array(createRect(1, 2, 3, 4), createRect(10, 20, 30, 40)); | |
169 | |
170 var builder = new codec.MessageBuilder(1, structs.NamedRegion.encodedSize); | |
171 builder.encodeStruct(structs.NamedRegion, r); | |
172 var reader = new codec.MessageReader(builder.finish()); | |
173 var result = reader.decodeStruct(structs.NamedRegion); | |
174 | |
175 expect(result.name).toEqual("rectangle"); | |
176 expect(result.rects[0]).toEqual(createRect(1, 2, 3, 4)); | |
177 expect(result.rects[1]).toEqual(createRect(10, 20, 30, 40)); | |
178 } | |
179 | |
180 // Verify that a single boolean field in a struct is correctly decoded to | |
181 // boolean type. | |
182 function testSingleBooleanStruct() { | |
183 var single_bool = new structs.SingleBoolStruct(); | |
184 single_bool.value = true; | |
185 | |
186 var builder = new codec.MessageBuilder( | |
187 1, structs.SingleBoolStruct.encodedSize); | |
188 builder.encodeStruct(structs.SingleBoolStruct, single_bool); | |
189 var reader = new codec.MessageReader(builder.finish()); | |
190 var result = reader.decodeStruct(structs.SingleBoolStruct); | |
191 | |
192 // Use toEqual() instead of toBeTruthy() to make sure the field type is | |
193 // actually boolean. | |
194 expect(result.value).toEqual(true); | |
195 } | |
196 | |
197 function testTypes() { | |
198 function encodeDecode(cls, input, expectedResult, encodedSize) { | |
199 var messageName = 42; | |
200 var payloadSize = encodedSize || cls.encodedSize; | |
201 | |
202 var builder = new codec.MessageBuilder(messageName, payloadSize); | |
203 builder.encodeStruct(cls, input) | |
204 var message = builder.finish(); | |
205 | |
206 var reader = new codec.MessageReader(message); | |
207 expect(reader.payloadSize).toBe(payloadSize); | |
208 expect(reader.messageName).toBe(messageName); | |
209 var result = reader.decodeStruct(cls); | |
210 expect(result).toEqual(expectedResult); | |
211 } | |
212 encodeDecode(codec.String, "banana", "banana", 24); | |
213 encodeDecode(codec.NullableString, null, null, 8); | |
214 encodeDecode(codec.Int8, -1, -1); | |
215 encodeDecode(codec.Int8, 0xff, -1); | |
216 encodeDecode(codec.Int16, -1, -1); | |
217 encodeDecode(codec.Int16, 0xff, 0xff); | |
218 encodeDecode(codec.Int16, 0xffff, -1); | |
219 encodeDecode(codec.Int32, -1, -1); | |
220 encodeDecode(codec.Int32, 0xffff, 0xffff); | |
221 encodeDecode(codec.Int32, 0xffffffff, -1); | |
222 encodeDecode(codec.Float, 1.0, 1.0); | |
223 encodeDecode(codec.Double, 1.0, 1.0); | |
224 } | |
225 | |
226 function testAlign() { | |
227 var aligned = [ | |
228 0, // 0 | |
229 8, // 1 | |
230 8, // 2 | |
231 8, // 3 | |
232 8, // 4 | |
233 8, // 5 | |
234 8, // 6 | |
235 8, // 7 | |
236 8, // 8 | |
237 16, // 9 | |
238 16, // 10 | |
239 16, // 11 | |
240 16, // 12 | |
241 16, // 13 | |
242 16, // 14 | |
243 16, // 15 | |
244 16, // 16 | |
245 24, // 17 | |
246 24, // 18 | |
247 24, // 19 | |
248 24, // 20 | |
249 ]; | |
250 for (var i = 0; i < aligned.length; ++i) | |
251 expect(codec.align(i)).toBe(aligned[i]); | |
252 } | |
253 | |
254 function testUtf8() { | |
255 var str = "B\u03ba\u1f79"; // some UCS-2 codepoints | |
256 var messageName = 42; | |
257 var payloadSize = 24; | |
258 | |
259 var builder = new codec.MessageBuilder(messageName, payloadSize); | |
260 var encoder = builder.createEncoder(8); | |
261 encoder.encodeStringPointer(str); | |
262 var message = builder.finish(); | |
263 var expectedMemory = new Uint8Array([ | |
264 /* 0: */ 24, 0, 0, 0, 0, 0, 0, 0, | |
265 /* 8: */ 0, 0, 0, 0, 42, 0, 0, 0, | |
266 /* 16: */ 0, 0, 0, 0, 0, 0, 0, 0, | |
267 /* 24: */ 8, 0, 0, 0, 0, 0, 0, 0, | |
268 /* 32: */ 14, 0, 0, 0, 6, 0, 0, 0, | |
269 /* 40: */ 0x42, 0xCE, 0xBA, 0xE1, 0xBD, 0xB9, 0, 0, | |
270 ]); | |
271 var actualMemory = new Uint8Array(message.buffer.arrayBuffer); | |
272 expect(actualMemory.length).toEqual(expectedMemory.length); | |
273 expect(actualMemory).toEqual(expectedMemory); | |
274 | |
275 var reader = new codec.MessageReader(message); | |
276 expect(reader.payloadSize).toBe(payloadSize); | |
277 expect(reader.messageName).toBe(messageName); | |
278 var str2 = reader.decoder.decodeStringPointer(); | |
279 expect(str2).toEqual(str); | |
280 } | |
281 | |
282 function testTypedPointerValidation() { | |
283 var encoder = new codec.MessageBuilder(42, 24).createEncoder(8); | |
284 function DummyClass() {}; | |
285 var testCases = [ | |
286 // method, args, invalid examples, valid examples | |
287 [encoder.encodeArrayPointer, [DummyClass], [75], | |
288 [[], null, undefined, new Uint8Array([])]], | |
289 [encoder.encodeStringPointer, [], [75, new String("foo")], | |
290 ["", "bar", null, undefined]], | |
291 [encoder.encodeMapPointer, [DummyClass, DummyClass], [75], | |
292 [new Map(), null, undefined]], | |
293 ]; | |
294 | |
295 testCases.forEach(function(test) { | |
296 var method = test[0]; | |
297 var baseArgs = test[1]; | |
298 var invalidExamples = test[2]; | |
299 var validExamples = test[3]; | |
300 | |
301 var encoder = new codec.MessageBuilder(42, 24).createEncoder(8); | |
302 invalidExamples.forEach(function(invalid) { | |
303 expect(function() { | |
304 method.apply(encoder, baseArgs.concat(invalid)); | |
305 }).toThrow(); | |
306 }); | |
307 | |
308 validExamples.forEach(function(valid) { | |
309 var encoder = new codec.MessageBuilder(42, 24).createEncoder(8); | |
310 method.apply(encoder, baseArgs.concat(valid)); | |
311 }); | |
312 }); | |
313 } | |
314 }); | |
OLD | NEW |