]>
Commit | Line | Data |
---|---|---|
f67539c2 TL |
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 | }); |