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 "gin/test/expect", | |
7 "mojo/public/js/bindings/codec", | |
8 "mojo/public/interfaces/bindings/tests/sample_service.mojom", | |
9 ], function(expect, codec, sample) { | |
10 testBar(); | |
11 testFoo(); | |
12 testTypes(); | |
13 testAlign(); | |
14 testUtf8(); | |
15 this.result = "PASS"; | |
16 | |
17 function testBar() { | |
18 var bar = new sample.Bar(); | |
19 bar.alpha = 1; | |
20 bar.beta = 2; | |
21 bar.gamma = 3; | |
22 bar.type = 0x08070605; | |
23 bar.extraProperty = "banana"; | |
24 | |
25 var messageName = 42; | |
26 var payloadSize = sample.Bar.encodedSize; | |
27 | |
28 var builder = new codec.MessageBuilder(messageName, payloadSize); | |
29 builder.encodeStruct(sample.Bar, bar); | |
30 | |
31 var message = builder.finish(); | |
32 | |
33 var expectedMemory = new Uint8Array([ | |
34 16, 0, 0, 0, | |
35 2, 0, 0, 0, | |
36 42, 0, 0, 0, | |
37 0, 0, 0, 0, | |
38 | |
39 16, 0, 0, 0, | |
40 4, 0, 0, 0, | |
41 | |
42 1, 2, 3, 0, | |
43 5, 6, 7, 8, | |
44 ]); | |
45 | |
46 var actualMemory = new Uint8Array(message.buffer.arrayBuffer); | |
47 expect(actualMemory).toEqual(expectedMemory); | |
48 | |
49 var reader = new codec.MessageReader(message); | |
50 | |
51 expect(reader.payloadSize).toBe(payloadSize); | |
52 expect(reader.messageName).toBe(messageName); | |
53 | |
54 var bar2 = reader.decodeStruct(sample.Bar); | |
55 | |
56 expect(bar2.alpha).toBe(bar.alpha); | |
57 expect(bar2.beta).toBe(bar.beta); | |
58 expect(bar2.gamma).toBe(bar.gamma); | |
59 expect("extraProperty" in bar2).toBeFalsy(); | |
60 } | |
61 | |
62 function testFoo() { | |
63 var foo = new sample.Foo(); | |
64 foo.x = 0x212B4D5; | |
65 foo.y = 0x16E93; | |
66 foo.a = 1; | |
67 foo.b = 0; | |
68 foo.c = 3; // This will get truncated to one bit. | |
69 foo.bar = new sample.Bar(); | |
70 foo.bar.alpha = 91; | |
71 foo.bar.beta = 82; | |
72 foo.bar.gamma = 73; | |
73 foo.data = [ | |
74 4, 5, 6, 7, 8, | |
75 ]; | |
76 foo.extra_bars = [ | |
77 new sample.Bar(), new sample.Bar(), new sample.Bar(), | |
78 ]; | |
79 for (var i = 0; i < foo.extra_bars.length; ++i) { | |
80 foo.extra_bars[i].alpha = 1 * i; | |
81 foo.extra_bars[i].beta = 2 * i; | |
82 foo.extra_bars[i].gamma = 3 * i; | |
83 } | |
84 foo.name = "I am a banana"; | |
85 // This is supposed to be a handle, but we fake it with an integer. | |
86 foo.source = 23423782; | |
87 foo.array_of_array_of_bools = [ | |
88 [true], [false, true] | |
89 ]; | |
90 foo.array_of_bools = [ | |
91 true, false, true, false, true, false, true, true | |
92 ]; | |
93 | |
94 | |
95 var messageName = 31; | |
96 var payloadSize = 304; | |
97 | |
98 var builder = new codec.MessageBuilder(messageName, payloadSize); | |
99 builder.encodeStruct(sample.Foo, foo); | |
100 | |
101 var message = builder.finish(); | |
102 | |
103 var expectedMemory = new Uint8Array([ | |
104 /* 0: */ 16, 0, 0, 0, 2, 0, 0, 0, | |
105 /* 8: */ 31, 0, 0, 0, 0, 0, 0, 0, | |
106 /* 16: */ 96, 0, 0, 0, 15, 0, 0, 0, | |
107 /* 24: */ 0xD5, 0xB4, 0x12, 0x02, 0x93, 0x6E, 0x01, 0, | |
108 /* 32: */ 5, 0, 0, 0, 0, 0, 0, 0, | |
109 /* 40: */ 72, 0, 0, 0, 0, 0, 0, 0, | |
110 ]); | |
111 // TODO(abarth): Test more of the message's raw memory. | |
112 var actualMemory = new Uint8Array(message.buffer.arrayBuffer, | |
113 0, expectedMemory.length); | |
114 expect(actualMemory).toEqual(expectedMemory); | |
115 | |
116 var expectedHandles = [ | |
117 23423782, | |
118 ]; | |
119 | |
120 expect(message.handles).toEqual(expectedHandles); | |
121 | |
122 var reader = new codec.MessageReader(message); | |
123 | |
124 expect(reader.payloadSize).toBe(payloadSize); | |
125 expect(reader.messageName).toBe(messageName); | |
126 | |
127 var foo2 = reader.decodeStruct(sample.Foo); | |
128 | |
129 expect(foo2.x).toBe(foo.x); | |
130 expect(foo2.y).toBe(foo.y); | |
131 | |
132 expect(foo2.a).toBe(foo.a & 1 ? true : false); | |
133 expect(foo2.b).toBe(foo.b & 1 ? true : false); | |
134 expect(foo2.c).toBe(foo.c & 1 ? true : false); | |
135 | |
136 expect(foo2.bar).toEqual(foo.bar); | |
137 expect(foo2.data).toEqual(foo.data); | |
138 | |
139 expect(foo2.extra_bars).toEqual(foo.extra_bars); | |
140 expect(foo2.name).toBe(foo.name); | |
141 expect(foo2.source).toEqual(foo.source); | |
142 | |
143 expect(foo2.array_of_bools).toEqual(foo.array_of_bools); | |
144 } | |
145 | |
146 function testTypes() { | |
147 function encodeDecode(cls, input, expectedResult, encodedSize) { | |
148 var messageName = 42; | |
149 var payloadSize = encodedSize || cls.encodedSize; | |
150 | |
151 var builder = new codec.MessageBuilder(messageName, payloadSize); | |
152 builder.encodeStruct(cls, input) | |
153 var message = builder.finish(); | |
154 | |
155 var reader = new codec.MessageReader(message); | |
156 expect(reader.payloadSize).toBe(payloadSize); | |
157 expect(reader.messageName).toBe(messageName); | |
158 var result = reader.decodeStruct(cls); | |
159 expect(result).toEqual(expectedResult); | |
160 } | |
161 encodeDecode(codec.String, "banana", "banana", 24); | |
162 encodeDecode(codec.Int8, -1, -1); | |
163 encodeDecode(codec.Int8, 0xff, -1); | |
164 encodeDecode(codec.Int16, -1, -1); | |
165 encodeDecode(codec.Int16, 0xff, 0xff); | |
166 encodeDecode(codec.Int16, 0xffff, -1); | |
167 encodeDecode(codec.Int32, -1, -1); | |
168 encodeDecode(codec.Int32, 0xffff, 0xffff); | |
169 encodeDecode(codec.Int32, 0xffffffff, -1); | |
170 encodeDecode(codec.Float, 1.0, 1.0); | |
171 encodeDecode(codec.Double, 1.0, 1.0); | |
172 } | |
173 | |
174 function testAlign() { | |
175 var aligned = [ | |
176 0, // 0 | |
177 8, // 1 | |
178 8, // 2 | |
179 8, // 3 | |
180 8, // 4 | |
181 8, // 5 | |
182 8, // 6 | |
183 8, // 7 | |
184 8, // 8 | |
185 16, // 9 | |
186 16, // 10 | |
187 16, // 11 | |
188 16, // 12 | |
189 16, // 13 | |
190 16, // 14 | |
191 16, // 15 | |
192 16, // 16 | |
193 24, // 17 | |
194 24, // 18 | |
195 24, // 19 | |
196 24, // 20 | |
197 ]; | |
198 for (var i = 0; i < aligned.length; ++i) | |
199 expect(codec.align(i)).toBe(aligned[i]); | |
200 } | |
201 | |
202 function testUtf8() { | |
203 var str = "B\u03ba\u1f79"; // some UCS-2 codepoints | |
204 var messageName = 42; | |
205 var payloadSize = 24; | |
206 | |
207 var builder = new codec.MessageBuilder(messageName, payloadSize); | |
208 var encoder = builder.createEncoder(8); | |
209 encoder.encodeStringPointer(str); | |
210 var message = builder.finish(); | |
211 var expectedMemory = new Uint8Array([ | |
212 /* 0: */ 16, 0, 0, 0, 2, 0, 0, 0, | |
213 /* 8: */ 42, 0, 0, 0, 0, 0, 0, 0, | |
214 /* 16: */ 8, 0, 0, 0, 0, 0, 0, 0, | |
215 /* 24: */ 14, 0, 0, 0, 6, 0, 0, 0, | |
216 /* 32: */ 0x42, 0xCE, 0xBA, 0xE1, 0xBD, 0xB9, 0, 0, | |
217 ]); | |
218 var actualMemory = new Uint8Array(message.buffer.arrayBuffer); | |
219 expect(actualMemory.length).toEqual(expectedMemory.length); | |
220 expect(actualMemory).toEqual(expectedMemory); | |
221 | |
222 var reader = new codec.MessageReader(message); | |
223 expect(reader.payloadSize).toBe(payloadSize); | |
224 expect(reader.messageName).toBe(messageName); | |
225 var str2 = reader.decoder.decodeStringPointer(); | |
226 expect(str2).toEqual(str); | |
227 } | |
228 }); | |
OLD | NEW |