| 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 import 'dart:typed_data'; | |
| 6 | |
| 7 import 'package:_mojo_for_test_only/expect.dart'; | |
| 8 import 'package:mojo/bindings.dart' as bindings; | |
| 9 import 'package:mojo/core.dart' as core; | |
| 10 | |
| 11 class Bar extends bindings.Struct { | |
| 12 static const int kStructSize = 16; | |
| 13 static const bindings.StructDataHeader kDefaultStructInfo = | |
| 14 const bindings.StructDataHeader(kStructSize, 4); | |
| 15 | |
| 16 static final int Type_VERTICAL = 1; | |
| 17 static final int Type_HORIZONTAL = Type_VERTICAL + 1; | |
| 18 static final int Type_BOTH = Type_HORIZONTAL + 1; | |
| 19 static final int Type_INVALID = Type_BOTH + 1; | |
| 20 int alpha; | |
| 21 int beta; | |
| 22 int gamma; | |
| 23 int type; | |
| 24 | |
| 25 Bar() : super(kStructSize) { | |
| 26 alpha = 0xff; | |
| 27 type = Bar.Type_VERTICAL; | |
| 28 } | |
| 29 | |
| 30 static Bar deserialize(bindings.Message message) { | |
| 31 return decode(new bindings.Decoder(message)); | |
| 32 } | |
| 33 | |
| 34 static Bar decode(bindings.Decoder decoder0) { | |
| 35 if (decoder0 == null) { | |
| 36 return null; | |
| 37 } | |
| 38 Bar result = new Bar(); | |
| 39 var mainDataHeader = decoder0.decodeStructDataHeader(); | |
| 40 if (mainDataHeader.version > 0) { | |
| 41 result.alpha = decoder0.decodeUint8(8); | |
| 42 } | |
| 43 if (mainDataHeader.version > 1) { | |
| 44 result.beta = decoder0.decodeUint8(9); | |
| 45 } | |
| 46 if (mainDataHeader.version > 2) { | |
| 47 result.gamma = decoder0.decodeUint8(10); | |
| 48 } | |
| 49 if (mainDataHeader.version > 3) { | |
| 50 result.type = decoder0.decodeInt32(12); | |
| 51 } | |
| 52 return result; | |
| 53 } | |
| 54 | |
| 55 void encode(bindings.Encoder encoder) { | |
| 56 var encoder0 = encoder.getStructEncoderAtOffset(kDefaultStructInfo); | |
| 57 encoder0.encodeUint8(alpha, 8); | |
| 58 encoder0.encodeUint8(beta, 9); | |
| 59 encoder0.encodeUint8(gamma, 10); | |
| 60 encoder0.encodeInt32(type, 12); | |
| 61 } | |
| 62 } | |
| 63 | |
| 64 void testBar() { | |
| 65 var bar = new Bar(); | |
| 66 bar.alpha = 1; | |
| 67 bar.beta = 2; | |
| 68 bar.gamma = 3; | |
| 69 bar.type = 0x08070605; | |
| 70 | |
| 71 int name = 42; | |
| 72 var header = new bindings.MessageHeader(name); | |
| 73 var message = bar.serializeWithHeader(header); | |
| 74 | |
| 75 var expectedMemory = new Uint8List.fromList([ | |
| 76 16, | |
| 77 0, | |
| 78 0, | |
| 79 0, | |
| 80 0, | |
| 81 0, | |
| 82 0, | |
| 83 0, | |
| 84 42, | |
| 85 0, | |
| 86 0, | |
| 87 0, | |
| 88 0, | |
| 89 0, | |
| 90 0, | |
| 91 0, | |
| 92 16, | |
| 93 0, | |
| 94 0, | |
| 95 0, | |
| 96 4, | |
| 97 0, | |
| 98 0, | |
| 99 0, | |
| 100 1, | |
| 101 2, | |
| 102 3, | |
| 103 0, | |
| 104 5, | |
| 105 6, | |
| 106 7, | |
| 107 8, | |
| 108 ]); | |
| 109 | |
| 110 var actualMemory = message.buffer.buffer.asUint8List(); | |
| 111 Expect.listEquals(expectedMemory, actualMemory); | |
| 112 | |
| 113 var receivedMessage = new bindings.ServiceMessage.fromMessage(message); | |
| 114 | |
| 115 Expect.equals(receivedMessage.header.size, header.size); | |
| 116 Expect.equals(receivedMessage.header.type, header.type); | |
| 117 | |
| 118 var bar2 = Bar.deserialize(receivedMessage.payload); | |
| 119 | |
| 120 Expect.equals(bar.alpha, bar2.alpha); | |
| 121 Expect.equals(bar.beta, bar2.beta); | |
| 122 Expect.equals(bar.gamma, bar2.gamma); | |
| 123 Expect.equals(bar.type, bar2.type); | |
| 124 } | |
| 125 | |
| 126 class Foo extends bindings.Struct { | |
| 127 static const int kStructSize = 96; | |
| 128 static const bindings.StructDataHeader kDefaultStructInfo = | |
| 129 const bindings.StructDataHeader(kStructSize, 15); | |
| 130 static final kFooby = "Fooby"; | |
| 131 int x = 0; | |
| 132 int y = 0; | |
| 133 bool a = true; | |
| 134 bool b = false; | |
| 135 bool c = false; | |
| 136 core.MojoHandle source = null; | |
| 137 Bar bar = null; | |
| 138 List<int> data = null; | |
| 139 List<Bar> extraBars = null; | |
| 140 String name = Foo.kFooby; | |
| 141 List<core.MojoHandle> inputStreams = null; | |
| 142 List<core.MojoHandle> outputStreams = null; | |
| 143 List<List<bool>> arrayOfArrayOfBools = null; | |
| 144 List<List<List<String>>> multiArrayOfStrings = null; | |
| 145 List<bool> arrayOfBools = null; | |
| 146 | |
| 147 Foo() : super(kStructSize); | |
| 148 | |
| 149 static Foo deserialize(bindings.Message message) { | |
| 150 return decode(new bindings.Decoder(message)); | |
| 151 } | |
| 152 | |
| 153 static Foo decode(bindings.Decoder decoder0) { | |
| 154 if (decoder0 == null) { | |
| 155 return null; | |
| 156 } | |
| 157 Foo result = new Foo(); | |
| 158 var mainDataHeader = decoder0.decodeStructDataHeader(); | |
| 159 if (mainDataHeader.version > 0) { | |
| 160 result.x = decoder0.decodeInt32(8); | |
| 161 } | |
| 162 if (mainDataHeader.version > 1) { | |
| 163 result.y = decoder0.decodeInt32(12); | |
| 164 } | |
| 165 if (mainDataHeader.version > 2) { | |
| 166 result.a = decoder0.decodeBool(16, 0); | |
| 167 } | |
| 168 if (mainDataHeader.version > 3) { | |
| 169 result.b = decoder0.decodeBool(16, 1); | |
| 170 } | |
| 171 if (mainDataHeader.version > 4) { | |
| 172 result.c = decoder0.decodeBool(16, 2); | |
| 173 } | |
| 174 if (mainDataHeader.version > 9) { | |
| 175 result.source = decoder0.decodeHandle(20, true); | |
| 176 } | |
| 177 if (mainDataHeader.version > 5) { | |
| 178 var decoder1 = decoder0.decodePointer(24, true); | |
| 179 result.bar = Bar.decode(decoder1); | |
| 180 } | |
| 181 if (mainDataHeader.version > 6) { | |
| 182 result.data = decoder0.decodeUint8Array( | |
| 183 32, bindings.kArrayNullable, bindings.kUnspecifiedArrayLength); | |
| 184 } | |
| 185 if (mainDataHeader.version > 7) { | |
| 186 var decoder1 = decoder0.decodePointer(40, true); | |
| 187 if (decoder1 == null) { | |
| 188 result.extraBars = null; | |
| 189 } else { | |
| 190 var si1 = decoder1 | |
| 191 .decodeDataHeaderForPointerArray(bindings.kUnspecifiedArrayLength); | |
| 192 result.extraBars = new List<Bar>(si1.numElements); | |
| 193 for (int i1 = 0; i1 < si1.numElements; ++i1) { | |
| 194 var decoder2 = decoder1.decodePointer( | |
| 195 bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i1, | |
| 196 false); | |
| 197 result.extraBars[i1] = Bar.decode(decoder2); | |
| 198 } | |
| 199 } | |
| 200 } | |
| 201 if (mainDataHeader.version > 8) { | |
| 202 result.name = decoder0.decodeString(48, false); | |
| 203 } | |
| 204 if (mainDataHeader.version > 10) { | |
| 205 result.inputStreams = decoder0.decodeHandleArray( | |
| 206 56, bindings.kArrayNullable, bindings.kUnspecifiedArrayLength); | |
| 207 } | |
| 208 if (mainDataHeader.version > 11) { | |
| 209 result.outputStreams = decoder0.decodeHandleArray( | |
| 210 64, bindings.kArrayNullable, bindings.kUnspecifiedArrayLength); | |
| 211 } | |
| 212 if (mainDataHeader.version > 12) { | |
| 213 var decoder1 = decoder0.decodePointer(72, true); | |
| 214 if (decoder1 == null) { | |
| 215 result.arrayOfArrayOfBools = null; | |
| 216 } else { | |
| 217 var si1 = decoder1 | |
| 218 .decodeDataHeaderForPointerArray(bindings.kUnspecifiedArrayLength); | |
| 219 result.arrayOfArrayOfBools = new List<List<bool>>(si1.numElements); | |
| 220 for (int i1 = 0; i1 < si1.numElements; ++i1) { | |
| 221 result.arrayOfArrayOfBools[i1] = decoder1.decodeBoolArray( | |
| 222 bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i1, | |
| 223 bindings.kNothingNullable, bindings.kUnspecifiedArrayLength); | |
| 224 } | |
| 225 } | |
| 226 } | |
| 227 if (mainDataHeader.version > 13) { | |
| 228 var decoder1 = decoder0.decodePointer(80, true); | |
| 229 if (decoder1 == null) { | |
| 230 result.multiArrayOfStrings = null; | |
| 231 } else { | |
| 232 var si1 = decoder1 | |
| 233 .decodeDataHeaderForPointerArray(bindings.kUnspecifiedArrayLength); | |
| 234 result.multiArrayOfStrings = | |
| 235 new List<List<List<String>>>(si1.numElements); | |
| 236 for (int i1 = 0; i1 < si1.numElements; ++i1) { | |
| 237 var decoder2 = decoder1.decodePointer( | |
| 238 bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i1, | |
| 239 false); | |
| 240 { | |
| 241 var si2 = decoder2.decodeDataHeaderForPointerArray( | |
| 242 bindings.kUnspecifiedArrayLength); | |
| 243 result.multiArrayOfStrings[i1] = | |
| 244 new List<List<String>>(si2.numElements); | |
| 245 for (int i2 = 0; i2 < si2.numElements; ++i2) { | |
| 246 var decoder3 = decoder2.decodePointer( | |
| 247 bindings.ArrayDataHeader.kHeaderSize + | |
| 248 bindings.kPointerSize * i2, false); | |
| 249 { | |
| 250 var si3 = decoder3.decodeDataHeaderForPointerArray( | |
| 251 bindings.kUnspecifiedArrayLength); | |
| 252 result.multiArrayOfStrings[i1][i2] = | |
| 253 new List<String>(si3.numElements); | |
| 254 for (int i3 = 0; i3 < si3.numElements; ++i3) { | |
| 255 var length = bindings.ArrayDataHeader.kHeaderSize + | |
| 256 bindings.kPointerSize * i3; | |
| 257 result.multiArrayOfStrings[i1][i2][i3] = | |
| 258 decoder3.decodeString(length, false); | |
| 259 } | |
| 260 } | |
| 261 } | |
| 262 } | |
| 263 } | |
| 264 } | |
| 265 } | |
| 266 if (mainDataHeader.version > 14) { | |
| 267 result.arrayOfBools = decoder0.decodeBoolArray( | |
| 268 88, bindings.kArrayNullable, bindings.kUnspecifiedArrayLength); | |
| 269 } | |
| 270 return result; | |
| 271 } | |
| 272 | |
| 273 void encode(bindings.Encoder encoder) { | |
| 274 var encoder0 = encoder.getStructEncoderAtOffset(kDefaultStructInfo); | |
| 275 encoder0.encodeInt32(x, 8); | |
| 276 encoder0.encodeInt32(y, 12); | |
| 277 encoder0.encodeBool(a, 16, 0); | |
| 278 encoder0.encodeBool(b, 16, 1); | |
| 279 encoder0.encodeBool(c, 16, 2); | |
| 280 encoder0.encodeHandle(source, 20, true); | |
| 281 encoder0.encodeStruct(bar, 24, true); | |
| 282 encoder0.encodeUint8Array( | |
| 283 data, 32, bindings.kArrayNullable, bindings.kUnspecifiedArrayLength); | |
| 284 | |
| 285 if (extraBars == null) { | |
| 286 encoder0.encodeNullPointer(40, true); | |
| 287 } else { | |
| 288 var encoder1 = encoder0.encodePointerArray( | |
| 289 extraBars.length, 40, bindings.kUnspecifiedArrayLength); | |
| 290 for (int i0 = 0; i0 < extraBars.length; ++i0) { | |
| 291 encoder1.encodeStruct(extraBars[i0], | |
| 292 bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i0, | |
| 293 false); | |
| 294 } | |
| 295 } | |
| 296 | |
| 297 encoder0.encodeString(name, 48, false); | |
| 298 encoder0.encodeHandleArray(inputStreams, 56, | |
| 299 bindings.kArrayNullable, bindings.kUnspecifiedArrayLength); | |
| 300 encoder0.encodeHandleArray(outputStreams, 64, bindings.kArrayNullable, | |
| 301 bindings.kUnspecifiedArrayLength); | |
| 302 | |
| 303 if (arrayOfArrayOfBools == null) { | |
| 304 encoder0.encodeNullPointer(72, true); | |
| 305 } else { | |
| 306 var encoder1 = encoder0.encodePointerArray( | |
| 307 arrayOfArrayOfBools.length, 72, bindings.kUnspecifiedArrayLength); | |
| 308 for (int i0 = 0; i0 < arrayOfArrayOfBools.length; ++i0) { | |
| 309 encoder1.encodeBoolArray(arrayOfArrayOfBools[i0], | |
| 310 bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i0, | |
| 311 bindings.kNothingNullable, bindings.kUnspecifiedArrayLength); | |
| 312 } | |
| 313 } | |
| 314 | |
| 315 if (multiArrayOfStrings == null) { | |
| 316 encoder0.encodeNullPointer(80, true); | |
| 317 } else { | |
| 318 var encoder1 = encoder0.encodePointerArray( | |
| 319 multiArrayOfStrings.length, 80, bindings.kUnspecifiedArrayLength); | |
| 320 for (int i0 = 0; i0 < multiArrayOfStrings.length; ++i0) { | |
| 321 if (multiArrayOfStrings[i0] == null) { | |
| 322 encoder1.encodeNullPointer( | |
| 323 bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i0, | |
| 324 false); | |
| 325 } else { | |
| 326 var encoder2 = encoder1.encodePointerArray( | |
| 327 multiArrayOfStrings[i0].length, | |
| 328 bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i0, | |
| 329 bindings.kUnspecifiedArrayLength); | |
| 330 for (int i1 = 0; i1 < multiArrayOfStrings[i0].length; ++i1) { | |
| 331 if (multiArrayOfStrings[i0][i1] == null) { | |
| 332 encoder2.encodeNullPointer(bindings.ArrayDataHeader.kHeaderSize + | |
| 333 bindings.kPointerSize * i1, false); | |
| 334 } else { | |
| 335 var encoder3 = encoder2.encodePointerArray( | |
| 336 multiArrayOfStrings[i0][i1].length, | |
| 337 bindings.ArrayDataHeader.kHeaderSize + | |
| 338 bindings.kPointerSize * i1, | |
| 339 bindings.kUnspecifiedArrayLength); | |
| 340 for (int i2 = 0; i2 < multiArrayOfStrings[i0][i1].length; ++i2) { | |
| 341 var length = bindings.ArrayDataHeader.kHeaderSize + | |
| 342 bindings.kPointerSize * i2; | |
| 343 encoder3.encodeString( | |
| 344 multiArrayOfStrings[i0][i1][i2], length, false); | |
| 345 } | |
| 346 } | |
| 347 } | |
| 348 } | |
| 349 } | |
| 350 } | |
| 351 | |
| 352 encoder0.encodeBoolArray(arrayOfBools, 88, bindings.kArrayNullable, | |
| 353 bindings.kUnspecifiedArrayLength); | |
| 354 } | |
| 355 } | |
| 356 | |
| 357 void testFoo() { | |
| 358 var foo = new Foo(); | |
| 359 foo.x = 0x212B4D5; | |
| 360 foo.y = 0x16E93; | |
| 361 foo.a = true; | |
| 362 foo.b = false; | |
| 363 foo.c = true; | |
| 364 foo.bar = new Bar(); | |
| 365 foo.bar.alpha = 91; | |
| 366 foo.bar.beta = 82; | |
| 367 foo.bar.gamma = 73; | |
| 368 foo.data = [4, 5, 6, 7, 8,]; | |
| 369 foo.extraBars = [new Bar(), new Bar(), new Bar(),]; | |
| 370 for (int i = 0; i < foo.extraBars.length; ++i) { | |
| 371 foo.extraBars[i].alpha = 1 * i; | |
| 372 foo.extraBars[i].beta = 2 * i; | |
| 373 foo.extraBars[i].gamma = 3 * i; | |
| 374 } | |
| 375 foo.name = "I am a banana"; | |
| 376 // This is supposed to be a handle, but we fake it with an integer. | |
| 377 foo.source = new core.MojoHandle(23423782); | |
| 378 foo.arrayOfArrayOfBools = [[true], [false, true]]; | |
| 379 foo.arrayOfBools = [true, false, true, false, true, false, true, true]; | |
| 380 | |
| 381 int name = 31; | |
| 382 var header = new bindings.MessageHeader(name); | |
| 383 var message = foo.serializeWithHeader(header); | |
| 384 | |
| 385 var expectedMemory = new Uint8List.fromList([ | |
| 386 /* 0: */ 16, | |
| 387 0, | |
| 388 0, | |
| 389 0, | |
| 390 0, | |
| 391 0, | |
| 392 0, | |
| 393 0, | |
| 394 /* 8: */ 31, | |
| 395 0, | |
| 396 0, | |
| 397 0, | |
| 398 0, | |
| 399 0, | |
| 400 0, | |
| 401 0, | |
| 402 /* 16: */ 96, | |
| 403 0, | |
| 404 0, | |
| 405 0, | |
| 406 15, | |
| 407 0, | |
| 408 0, | |
| 409 0, | |
| 410 /* 24: */ 0xD5, | |
| 411 0xB4, | |
| 412 0x12, | |
| 413 0x02, | |
| 414 0x93, | |
| 415 0x6E, | |
| 416 0x01, | |
| 417 0, | |
| 418 /* 32: */ 5, | |
| 419 0, | |
| 420 0, | |
| 421 0, | |
| 422 0, | |
| 423 0, | |
| 424 0, | |
| 425 0, | |
| 426 /* 40: */ 72, | |
| 427 0, | |
| 428 0, | |
| 429 0, | |
| 430 0, | |
| 431 0, | |
| 432 0, | |
| 433 0, | |
| 434 ]); | |
| 435 | |
| 436 var allActualMemory = message.buffer.buffer.asUint8List(); | |
| 437 var actualMemory = allActualMemory.sublist(0, expectedMemory.length); | |
| 438 Expect.listEquals(expectedMemory, actualMemory); | |
| 439 | |
| 440 var expectedHandles = <core.MojoHandle>[new core.MojoHandle(23423782),]; | |
| 441 | |
| 442 Expect.listEquals(expectedHandles, message.handles); | |
| 443 | |
| 444 var receivedMessage = new bindings.ServiceMessage.fromMessage(message); | |
| 445 | |
| 446 Expect.equals(receivedMessage.header.size, header.size); | |
| 447 Expect.equals(receivedMessage.header.type, header.type); | |
| 448 | |
| 449 var foo2 = Foo.deserialize(receivedMessage.payload); | |
| 450 | |
| 451 Expect.equals(foo.x, foo2.x); | |
| 452 Expect.equals(foo.y, foo2.y); | |
| 453 | |
| 454 Expect.equals(foo.a, foo2.a); | |
| 455 Expect.equals(foo.b, foo2.b); | |
| 456 Expect.equals(foo.c, foo2.c); | |
| 457 | |
| 458 Expect.equals(foo.bar.alpha, foo2.bar.alpha); | |
| 459 Expect.equals(foo.bar.beta, foo2.bar.beta); | |
| 460 Expect.equals(foo.bar.gamma, foo2.bar.gamma); | |
| 461 Expect.equals(foo.bar.type, foo2.bar.type); | |
| 462 Expect.listEquals(foo.data, foo2.data); | |
| 463 | |
| 464 for (int i = 0; i < foo2.extraBars.length; i++) { | |
| 465 Expect.equals(foo.extraBars[i].alpha, foo2.extraBars[i].alpha); | |
| 466 Expect.equals(foo.extraBars[i].beta, foo2.extraBars[i].beta); | |
| 467 Expect.equals(foo.extraBars[i].gamma, foo2.extraBars[i].gamma); | |
| 468 Expect.equals(foo.extraBars[i].type, foo2.extraBars[i].type); | |
| 469 } | |
| 470 | |
| 471 Expect.equals(foo.name, foo2.name); | |
| 472 Expect.equals(foo.source, foo2.source); | |
| 473 | |
| 474 Expect.listEquals(foo.arrayOfBools, foo2.arrayOfBools); | |
| 475 for (int i = 0; i < foo2.arrayOfArrayOfBools.length; i++) { | |
| 476 Expect.listEquals(foo.arrayOfArrayOfBools[i], foo2.arrayOfArrayOfBools[i]); | |
| 477 } | |
| 478 } | |
| 479 | |
| 480 class Rect extends bindings.Struct { | |
| 481 static const int kStructSize = 24; | |
| 482 static const bindings.StructDataHeader kDefaultStructInfo = | |
| 483 const bindings.StructDataHeader(kStructSize, 4); | |
| 484 int x; | |
| 485 int y; | |
| 486 int width; | |
| 487 int height; | |
| 488 | |
| 489 Rect() : super(kStructSize); | |
| 490 | |
| 491 static Rect deserialize(bindings.Message message) { | |
| 492 return decode(new bindings.Decoder(message)); | |
| 493 } | |
| 494 | |
| 495 static Rect decode(bindings.Decoder decoder0) { | |
| 496 if (decoder0 == null) { | |
| 497 return null; | |
| 498 } | |
| 499 Rect result = new Rect(); | |
| 500 var mainDataHeader = decoder0.decodeStructDataHeader(); | |
| 501 if (mainDataHeader.version > 0) { | |
| 502 result.x = decoder0.decodeInt32(8); | |
| 503 } | |
| 504 if (mainDataHeader.version > 1) { | |
| 505 result.y = decoder0.decodeInt32(12); | |
| 506 } | |
| 507 if (mainDataHeader.version > 2) { | |
| 508 result.width = decoder0.decodeInt32(16); | |
| 509 } | |
| 510 if (mainDataHeader.version > 3) { | |
| 511 result.height = decoder0.decodeInt32(20); | |
| 512 } | |
| 513 return result; | |
| 514 } | |
| 515 | |
| 516 void encode(bindings.Encoder encoder) { | |
| 517 var encoder0 = encoder.getStructEncoderAtOffset(kDefaultStructInfo); | |
| 518 encoder0.encodeInt32(x, 8); | |
| 519 encoder0.encodeInt32(y, 12); | |
| 520 encoder0.encodeInt32(width, 16); | |
| 521 encoder0.encodeInt32(height, 20); | |
| 522 } | |
| 523 | |
| 524 bool operator ==(Rect other) => (this.x == other.x) && | |
| 525 (this.y == other.y) && | |
| 526 (this.width == other.width) && | |
| 527 (this.height == other.height); | |
| 528 } | |
| 529 | |
| 530 Rect createRect(int x, int y, int width, int height) { | |
| 531 var r = new Rect(); | |
| 532 r.x = x; | |
| 533 r.y = y; | |
| 534 r.width = width; | |
| 535 r.height = height; | |
| 536 return r; | |
| 537 } | |
| 538 | |
| 539 class NamedRegion extends bindings.Struct { | |
| 540 static const int kStructSize = 24; | |
| 541 static const bindings.StructDataHeader kDefaultStructInfo = | |
| 542 const bindings.StructDataHeader(kStructSize, 2); | |
| 543 String name; | |
| 544 List<Rect> rects; | |
| 545 | |
| 546 NamedRegion() : super(kStructSize); | |
| 547 | |
| 548 static NamedRegion deserialize(bindings.Message message) { | |
| 549 return decode(new bindings.Decoder(message)); | |
| 550 } | |
| 551 | |
| 552 static NamedRegion decode(bindings.Decoder decoder0) { | |
| 553 if (decoder0 == null) { | |
| 554 return null; | |
| 555 } | |
| 556 NamedRegion result = new NamedRegion(); | |
| 557 var mainDataHeader = decoder0.decodeStructDataHeader(); | |
| 558 if (mainDataHeader.version > 0) { | |
| 559 result.name = decoder0.decodeString(8, true); | |
| 560 } | |
| 561 if (mainDataHeader.version > 1) { | |
| 562 var decoder1 = decoder0.decodePointer(16, true); | |
| 563 if (decoder1 == null) { | |
| 564 result.rects = null; | |
| 565 } else { | |
| 566 var si1 = decoder1 | |
| 567 .decodeDataHeaderForPointerArray(bindings.kUnspecifiedArrayLength); | |
| 568 result.rects = new List<Rect>(si1.numElements); | |
| 569 for (int i1 = 0; i1 < si1.numElements; ++i1) { | |
| 570 var decoder2 = decoder1.decodePointer( | |
| 571 bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i1, | |
| 572 false); | |
| 573 result.rects[i1] = Rect.decode(decoder2); | |
| 574 } | |
| 575 } | |
| 576 } | |
| 577 return result; | |
| 578 } | |
| 579 | |
| 580 void encode(bindings.Encoder encoder) { | |
| 581 var encoder0 = encoder.getStructEncoderAtOffset(kDefaultStructInfo); | |
| 582 encoder0.encodeString(name, 8, true); | |
| 583 if (rects == null) { | |
| 584 encoder0.encodeNullPointer(16, true); | |
| 585 } else { | |
| 586 var encoder1 = encoder0.encodePointerArray( | |
| 587 rects.length, 16, bindings.kUnspecifiedArrayLength); | |
| 588 for (int i0 = 0; i0 < rects.length; ++i0) { | |
| 589 encoder1.encodeStruct(rects[i0], | |
| 590 bindings.ArrayDataHeader.kHeaderSize + bindings.kPointerSize * i0, | |
| 591 false); | |
| 592 } | |
| 593 } | |
| 594 } | |
| 595 } | |
| 596 | |
| 597 testNamedRegion() { | |
| 598 var r = new NamedRegion(); | |
| 599 r.name = "rectangle"; | |
| 600 r.rects = [createRect(1, 2, 3, 4), createRect(10, 20, 30, 40)]; | |
| 601 | |
| 602 int name = 1; | |
| 603 var header = new bindings.MessageHeader(name); | |
| 604 var message = r.serializeWithHeader(header); | |
| 605 var resultMessage = new bindings.ServiceMessage.fromMessage(message); | |
| 606 var result = NamedRegion.deserialize(resultMessage.payload); | |
| 607 | |
| 608 Expect.equals("rectangle", result.name); | |
| 609 Expect.equals(createRect(1, 2, 3, 4), result.rects[0]); | |
| 610 Expect.equals(createRect(10, 20, 30, 40), result.rects[1]); | |
| 611 } | |
| 612 | |
| 613 void testAlign() { | |
| 614 List aligned = [ | |
| 615 0, // 0 | |
| 616 8, // 1 | |
| 617 8, // 2 | |
| 618 8, // 3 | |
| 619 8, // 4 | |
| 620 8, // 5 | |
| 621 8, // 6 | |
| 622 8, // 7 | |
| 623 8, // 8 | |
| 624 16, // 9 | |
| 625 16, // 10 | |
| 626 16, // 11 | |
| 627 16, // 12 | |
| 628 16, // 13 | |
| 629 16, // 14 | |
| 630 16, // 15 | |
| 631 16, // 16 | |
| 632 24, // 17 | |
| 633 24, // 18 | |
| 634 24, // 19 | |
| 635 24, // 20 | |
| 636 ]; | |
| 637 for (int i = 0; i < aligned.length; ++i) { | |
| 638 Expect.equals(bindings.align(i), aligned[i]); | |
| 639 } | |
| 640 } | |
| 641 | |
| 642 class MojoString extends bindings.Struct { | |
| 643 static const int kStructSize = 16; | |
| 644 static const bindings.StructDataHeader kDefaultStructInfo = | |
| 645 const bindings.StructDataHeader(kStructSize, 1); | |
| 646 String string; | |
| 647 MojoString() : super(kStructSize); | |
| 648 | |
| 649 static MojoString deserialize(bindings.Message message) { | |
| 650 return decode(new bindings.Decoder(message)); | |
| 651 } | |
| 652 | |
| 653 static MojoString decode(bindings.Decoder decoder0) { | |
| 654 if (decoder0 == null) { | |
| 655 return null; | |
| 656 } | |
| 657 MojoString result = new MojoString(); | |
| 658 var mainDataHeader = decoder0.decodeStructDataHeader(); | |
| 659 result.string = decoder0.decodeString(8, false); | |
| 660 return result; | |
| 661 } | |
| 662 | |
| 663 void encode(bindings.Encoder encoder) { | |
| 664 var encoder0 = encoder.getStructEncoderAtOffset(kDefaultStructInfo); | |
| 665 encoder0.encodeString(string, 8, false); | |
| 666 } | |
| 667 } | |
| 668 | |
| 669 testUtf8() { | |
| 670 var str = "B\u03ba\u1f79"; // some UCS-2 codepoints. | |
| 671 var name = 42; | |
| 672 var payloadSize = 24; | |
| 673 | |
| 674 var mojoString = new MojoString(); | |
| 675 mojoString.string = str; | |
| 676 | |
| 677 var header = new bindings.MessageHeader(name); | |
| 678 var message = mojoString.serializeWithHeader(header); | |
| 679 var resultMessage = new bindings.ServiceMessage.fromMessage(message); | |
| 680 var result = MojoString.deserialize(resultMessage.payload); | |
| 681 | |
| 682 var expectedMemory = new Uint8List.fromList([ | |
| 683 /* 0: */ 16, | |
| 684 0, | |
| 685 0, | |
| 686 0, | |
| 687 0, | |
| 688 0, | |
| 689 0, | |
| 690 0, | |
| 691 /* 8: */ 42, | |
| 692 0, | |
| 693 0, | |
| 694 0, | |
| 695 0, | |
| 696 0, | |
| 697 0, | |
| 698 0, | |
| 699 /* 16: */ 16, | |
| 700 0, | |
| 701 0, | |
| 702 0, | |
| 703 1, | |
| 704 0, | |
| 705 0, | |
| 706 0, | |
| 707 /* 24: */ 8, | |
| 708 0, | |
| 709 0, | |
| 710 0, | |
| 711 0, | |
| 712 0, | |
| 713 0, | |
| 714 0, | |
| 715 /* 32: */ 14, | |
| 716 0, | |
| 717 0, | |
| 718 0, | |
| 719 6, | |
| 720 0, | |
| 721 0, | |
| 722 0, | |
| 723 /* 40: */ 0x42, | |
| 724 0xCE, | |
| 725 0xBA, | |
| 726 0xE1, | |
| 727 0xBD, | |
| 728 0xB9, | |
| 729 0, | |
| 730 0, | |
| 731 ]); | |
| 732 var allActualMemory = message.buffer.buffer.asUint8List(); | |
| 733 var actualMemory = allActualMemory.sublist(0, expectedMemory.length); | |
| 734 Expect.equals(expectedMemory.length, actualMemory.length); | |
| 735 Expect.listEquals(expectedMemory, actualMemory); | |
| 736 | |
| 737 Expect.equals(str, result.string); | |
| 738 } | |
| 739 | |
| 740 main() { | |
| 741 testAlign(); | |
| 742 testBar(); | |
| 743 testFoo(); | |
| 744 testNamedRegion(); | |
| 745 testUtf8(); | |
| 746 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
