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