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