src/mojo/bindings/js/codec_unittests.js

   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
  91     var messageName = 31;
  92     var payloadSize = 304;
  93
  94     var builder = new codec.MessageBuilder(messageName, payloadSize);
  95     builder.encodeStruct(sample.Foo, foo);
  96
  97     var message = builder.finish();
  98
  99     var expectedMemory = new Uint8Array([
 100       /*  0: */   16,    0,    0,    0,    2,    0,    0,    0,
 101       /*  8: */   31,    0,    0,    0,    0,    0,    0,    0,
 102       /* 16: */   88,    0,    0,    0,   14,    0,    0,    0,
 103       /* 24: */ 0xD5, 0xB4, 0x12, 0x02, 0x93, 0x6E, 0x01,    0,
 104       /* 32: */    5,    0,    0,    0,    0,    0,    0,    0,
 105       /* 40: */   64,    0,    0,    0,    0,    0,    0,    0,
 106     ]);
 107     // TODO(abarth): Test more of the message's raw memory.
 108     var actualMemory = new Uint8Array(message.buffer.arrayBuffer,
 109                                       0, expectedMemory.length);
 110     expect(actualMemory).toEqual(expectedMemory);
 111
 112     var expectedHandles = [
 113       23423782,
 114     ];
 115
 116     expect(message.handles).toEqual(expectedHandles);
 117
 118     var reader = new codec.MessageReader(message);
 119
 120     expect(reader.payloadSize).toBe(payloadSize);
 121     expect(reader.messageName).toBe(messageName);
 122
 123     var foo2 = reader.decodeStruct(sample.Foo);
 124
 125     expect(foo2.x).toBe(foo.x);
 126     expect(foo2.y).toBe(foo.y);
 127
 128     expect(foo2.a).toBe(foo.a & 1 ? true : false);
 129     expect(foo2.b).toBe(foo.b & 1 ? true : false);
 130     expect(foo2.c).toBe(foo.c & 1 ? true : false);
 131
 132     expect(foo2.bar).toEqual(foo.bar);
 133     expect(foo2.data).toEqual(foo.data);
 134
 135     expect(foo2.extra_bars).toEqual(foo.extra_bars);
 136     expect(foo2.name).toBe(foo.name);
 137     expect(foo2.source).toEqual(foo.source);
 138   }
 139
 140   function testTypes() {
 141     function encodeDecode(cls, input, expectedResult, encodedSize) {
 142       var messageName = 42;
 143       var payloadSize = encodedSize || cls.encodedSize;
 144
 145       var builder = new codec.MessageBuilder(messageName, payloadSize);
 146       builder.encodeStruct(cls, input)
 147       var message = builder.finish();
 148
 149       var reader = new codec.MessageReader(message);
 150       expect(reader.payloadSize).toBe(payloadSize);
 151       expect(reader.messageName).toBe(messageName);
 152       var result = reader.decodeStruct(cls);
 153       expect(result).toEqual(expectedResult);
 154     }
 155     encodeDecode(codec.String, "banana", "banana", 24);
 156     encodeDecode(codec.Int8, -1, -1);
 157     encodeDecode(codec.Int8, 0xff, -1);
 158     encodeDecode(codec.Int16, -1, -1);
 159     encodeDecode(codec.Int16, 0xff, 0xff);
 160     encodeDecode(codec.Int16, 0xffff, -1);
 161     encodeDecode(codec.Int32, -1, -1);
 162     encodeDecode(codec.Int32, 0xffff, 0xffff);
 163     encodeDecode(codec.Int32, 0xffffffff, -1);
 164     encodeDecode(codec.Float, 1.0, 1.0);
 165     encodeDecode(codec.Double, 1.0, 1.0);
 166   }
 167
 168   function testAlign() {
 169     var aligned = [
 170       0, // 0
 171       8, // 1
 172       8, // 2
 173       8, // 3
 174       8, // 4
 175       8, // 5
 176       8, // 6
 177       8, // 7
 178       8, // 8
 179       16, // 9
 180       16, // 10
 181       16, // 11
 182       16, // 12
 183       16, // 13
 184       16, // 14
 185       16, // 15
 186       16, // 16
 187       24, // 17
 188       24, // 18
 189       24, // 19
 190       24, // 20
 191     ];
 192     for (var i = 0; i < aligned.length; ++i)
 193       expect(codec.align(i)).toBe(aligned[i]);
 194   }
 195
 196   function testUtf8() {
 197     var str = "B\u03ba\u1f79";  // some UCS-2 codepoints
 198     var messageName = 42;
 199     var payloadSize = 24;
 200
 201     var builder = new codec.MessageBuilder(messageName, payloadSize);
 202     var encoder = builder.createEncoder(8);
 203     encoder.encodeStringPointer(str);
 204     var message = builder.finish();
 205     var expectedMemory = new Uint8Array([
 206       /*  0: */   16,    0,    0,    0,    2,    0,    0,    0,
 207       /*  8: */   42,    0,    0,    0,    0,    0,    0,    0,
 208       /* 16: */    8,    0,    0,    0,    0,    0,    0,    0,
 209       /* 24: */   14,    0,    0,    0,    6,    0,    0,    0,
 210       /* 32: */ 0x42, 0xCE, 0xBA, 0xE1, 0xBD, 0xB9,    0,    0,
 211     ]);
 212     var actualMemory = new Uint8Array(message.buffer.arrayBuffer);
 213     expect(actualMemory.length).toEqual(expectedMemory.length);
 214     expect(actualMemory).toEqual(expectedMemory);
 215
 216     var reader = new codec.MessageReader(message);
 217     expect(reader.payloadSize).toBe(payloadSize);
 218     expect(reader.messageName).toBe(messageName);
 219     var str2 = reader.decoder.decodeStringPointer();
 220     expect(str2).toEqual(str);
 221   }
 222 });