ceph/src/jaegertracing/thrift/lib/nodejs/test/binary.test.js

   1 /*
   2  * Licensed to the Apache Software Foundation (ASF) under one
   3  * or more contributor license agreements. See the NOTICE file
   4  * distributed with this work for additional information
   5  * regarding copyright ownership. The ASF licenses this file
   6  * to you under the Apache License, Version 2.0 (the
   7  * "License"); you may not use this file except in compliance
   8  * with the License. You may obtain a copy of the License at
   9  *
  10  *   http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing,
  13  * software distributed under the License is distributed on an
  14  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  15  * KIND, either express or implied. See the License for the
  16  * specific language governing permissions and limitations
  17  * under the License.
  18  */
  19
  20 const test = require("tape");
  21 const binary = require("thrift/binary");
  22
  23 const cases = {
  24   "Should read signed byte": function(assert) {
  25     assert.equal(1, binary.readByte(0x01));
  26     assert.equal(-1, binary.readByte(0xff));
  27
  28     assert.equal(127, binary.readByte(0x7f));
  29     assert.equal(-128, binary.readByte(0x80));
  30     assert.end();
  31   },
  32   "Should write byte": function(assert) {
  33     //Protocol simply writes to the buffer. Nothing to test.. yet.
  34     assert.ok(true);
  35     assert.end();
  36   },
  37   "Should read I16": function(assert) {
  38     assert.equal(0, binary.readI16([0x00, 0x00]));
  39     assert.equal(1, binary.readI16([0x00, 0x01]));
  40     assert.equal(-1, binary.readI16([0xff, 0xff]));
  41
  42     // Min I16
  43     assert.equal(-32768, binary.readI16([0x80, 0x00]));
  44     // Max I16
  45     assert.equal(32767, binary.readI16([0x7f, 0xff]));
  46     assert.end();
  47   },
  48
  49   "Should write I16": function(assert) {
  50     assert.deepEqual([0x00, 0x00], binary.writeI16([], 0));
  51     assert.deepEqual([0x00, 0x01], binary.writeI16([], 1));
  52     assert.deepEqual([0xff, 0xff], binary.writeI16([], -1));
  53
  54     // Min I16
  55     assert.deepEqual([0x80, 0x00], binary.writeI16([], -32768));
  56     // Max I16
  57     assert.deepEqual([0x7f, 0xff], binary.writeI16([], 32767));
  58     assert.end();
  59   },
  60
  61   "Should read I32": function(assert) {
  62     assert.equal(0, binary.readI32([0x00, 0x00, 0x00, 0x00]));
  63     assert.equal(1, binary.readI32([0x00, 0x00, 0x00, 0x01]));
  64     assert.equal(-1, binary.readI32([0xff, 0xff, 0xff, 0xff]));
  65
  66     // Min I32
  67     assert.equal(-2147483648, binary.readI32([0x80, 0x00, 0x00, 0x00]));
  68     // Max I32
  69     assert.equal(2147483647, binary.readI32([0x7f, 0xff, 0xff, 0xff]));
  70     assert.end();
  71   },
  72
  73   "Should write I32": function(assert) {
  74     assert.deepEqual([0x00, 0x00, 0x00, 0x00], binary.writeI32([], 0));
  75     assert.deepEqual([0x00, 0x00, 0x00, 0x01], binary.writeI32([], 1));
  76     assert.deepEqual([0xff, 0xff, 0xff, 0xff], binary.writeI32([], -1));
  77
  78     // Min I32
  79     assert.deepEqual(
  80       [0x80, 0x00, 0x00, 0x00],
  81       binary.writeI32([], -2147483648)
  82     );
  83     // Max I32
  84     assert.deepEqual([0x7f, 0xff, 0xff, 0xff], binary.writeI32([], 2147483647));
  85     assert.end();
  86   },
  87
  88   "Should read doubles": function(assert) {
  89     assert.equal(
  90       0,
  91       binary.readDouble([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
  92     );
  93     assert.equal(
  94       0,
  95       binary.readDouble([0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
  96     );
  97     assert.equal(
  98       1,
  99       binary.readDouble([0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
 100     );
 101     assert.equal(
 102       2,
 103       binary.readDouble([0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
 104     );
 105     assert.equal(
 106       -2,
 107       binary.readDouble([0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
 108     );
 109
 110     assert.equal(
 111       Math.PI,
 112       binary.readDouble([0x40, 0x9, 0x21, 0xfb, 0x54, 0x44, 0x2d, 0x18])
 113     );
 114
 115     assert.equal(
 116       Infinity,
 117       binary.readDouble([0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
 118     );
 119     assert.equal(
 120       -Infinity,
 121       binary.readDouble([0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
 122     );
 123
 124     assert.ok(
 125       isNaN(binary.readDouble([0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
 126     );
 127
 128     assert.equal(
 129       1 / 3,
 130       binary.readDouble([0x3f, 0xd5, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55])
 131     );
 132
 133     // Min subnormal positive double
 134     assert.equal(
 135       4.9406564584124654e-324,
 136       binary.readDouble([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01])
 137     );
 138     // Min normal positive double
 139     assert.equal(
 140       2.2250738585072014e-308,
 141       binary.readDouble([0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
 142     );
 143     // Max positive double
 144     assert.equal(
 145       1.7976931348623157e308,
 146       binary.readDouble([0x7f, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff])
 147     );
 148     assert.end();
 149   },
 150
 151   "Should write doubles": function(assert) {
 152     assert.deepEqual(
 153       [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
 154       binary.writeDouble([], 0)
 155     );
 156     assert.deepEqual(
 157       [0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
 158       binary.writeDouble([], 1)
 159     );
 160     assert.deepEqual(
 161       [0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
 162       binary.writeDouble([], 2)
 163     );
 164     assert.deepEqual(
 165       [0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
 166       binary.writeDouble([], -2)
 167     );
 168
 169     assert.deepEqual(
 170       [0x40, 0x9, 0x21, 0xfb, 0x54, 0x44, 0x2d, 0x18],
 171       binary.writeDouble([], Math.PI)
 172     );
 173
 174     assert.deepEqual(
 175       [0x7f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
 176       binary.writeDouble([], Infinity)
 177     );
 178     assert.deepEqual(
 179       [0xff, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
 180       binary.writeDouble([], -Infinity)
 181     );
 182
 183     assert.deepEqual(
 184       [0x7f, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
 185       binary.writeDouble([], NaN)
 186     );
 187
 188     assert.deepEqual(
 189       [0x3f, 0xd5, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55],
 190       binary.writeDouble([], 1 / 3)
 191     );
 192
 193     // Min subnormal positive double
 194     assert.deepEqual(
 195       [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01],
 196       binary.writeDouble([], 4.9406564584124654e-324)
 197     );
 198     // Min normal positive double
 199     assert.deepEqual(
 200       [0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
 201       binary.writeDouble([], 2.2250738585072014e-308)
 202     );
 203     // Max positive double
 204     assert.deepEqual(
 205       [0x7f, 0xef, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff],
 206       binary.writeDouble([], 1.7976931348623157e308)
 207     );
 208     assert.end();
 209   }
 210 };
 211
 212 Object.keys(cases).forEach(function(caseName) {
 213   test(caseName, cases[caseName]);
 214 });