]>
Commit | Line | Data |
---|---|---|
1d09f67e TL |
1 | // Licensed to the Apache Software Foundation (ASF) under one |
2 | // or more contributor license agreements. See the NOTICE file | |
3 | // distributed with this work for additional information | |
4 | // regarding copyright ownership. The ASF licenses this file | |
5 | // to you under the Apache License, Version 2.0 (the | |
6 | // "License"); you may not use this file except in compliance | |
7 | // with the License. You may obtain a copy of the License at | |
8 | // | |
9 | // http://www.apache.org/licenses/LICENSE-2.0 | |
10 | // | |
11 | // Unless required by applicable law or agreed to in writing, | |
12 | // software distributed under the License is distributed on an | |
13 | // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
14 | // KIND, either express or implied. See the License for the | |
15 | // specific language governing permissions and limitations | |
16 | // under the License. | |
17 | ||
18 | import * as Arrow from 'apache-arrow'; | |
19 | const { Int64, Uint64, Int128 } = Arrow.util; | |
20 | ||
21 | describe(`Uint64`, () => { | |
22 | test(`gets expected high/low bytes`, () => { | |
23 | let i = new Uint64(new Uint32Array([5, 0])); | |
24 | expect(i.high()).toEqual(0); | |
25 | expect(i.low()).toEqual(5); | |
26 | }); | |
27 | test(`adds 32-bit numbers`, () => { | |
28 | let a = new Uint64(new Uint32Array([5, 0])); | |
29 | let b = new Uint64(new Uint32Array([9, 0])); | |
30 | let expected = new Uint64(new Uint32Array([14, 0])); | |
31 | expect(a.plus(b)).toEqual(expected); | |
32 | }); | |
33 | test(`addition overflows 32-bit numbers`, () => { | |
34 | let a = new Uint64(new Uint32Array([0xffffffff, 0])); | |
35 | let b = new Uint64(new Uint32Array([9, 0])); | |
36 | let expected = new Uint64(new Uint32Array([8, 1])); | |
37 | expect(a.plus(b)).toEqual(expected); | |
38 | }); | |
39 | test(`multiplies 32-bit numbers`, () => { | |
40 | let a = new Uint64(new Uint32Array([5, 0])); | |
41 | let b = new Uint64(new Uint32Array([9, 0])); | |
42 | let expected = new Uint64(new Uint32Array([45, 0])); | |
43 | expect(a.times(b)).toEqual(expected); | |
44 | }); | |
45 | test(`multiplication overflows 32-bit numbers`, () => { | |
46 | let a = new Uint64(new Uint32Array([0x80000000, 0])); | |
47 | let b = new Uint64(new Uint32Array([3, 0])); | |
48 | let expected = new Uint64(new Uint32Array([0x80000000, 1])); | |
49 | expect(a.times(b)).toEqual(expected); | |
50 | }); | |
51 | test(`multiplication is associative`, () => { | |
52 | let a = new Uint64(new Uint32Array([0x80000000, 0])); | |
53 | let b = new Uint64(new Uint32Array([3, 0])); | |
54 | expect(Uint64.multiply(a, b)).toEqual(Uint64.multiply(b,a)); | |
55 | }); | |
56 | test(`lessThan works on 32-bit numbers`, () => { | |
57 | let a = new Uint64(new Uint32Array([0x0000abcd, 0])); | |
58 | let b = new Uint64(new Uint32Array([0x0000abcf, 0])); | |
59 | expect(a.lessThan(b)).toBeTruthy(); | |
60 | }); | |
61 | test(`lessThan works on 64-bit numbers`, () => { | |
62 | let a = new Uint64(new Uint32Array([123, 32])); | |
63 | let b = new Uint64(new Uint32Array([568, 32])); | |
64 | expect(a.lessThan(b)).toBeTruthy(); | |
65 | }); | |
66 | test(`fromString parses string`, () => { | |
67 | expect(Uint64.fromString('6789123456789')).toEqual(new Int64(new Uint32Array([0xb74abf15, 0x62c]))); | |
68 | }); | |
69 | test(`fromString parses big (full unsigned 64-bit) string`, () => { | |
70 | expect(Uint64.fromString('18364758544493064720')).toEqual(new Uint64(new Uint32Array([0x76543210, 0xfedcba98]))); | |
71 | }); | |
72 | test(`fromNumber converts 53-ish bit number`, () => { | |
73 | expect(Uint64.fromNumber(8086463330923024)).toEqual(new Uint64(new Uint32Array([0x76543210, 0x001cba98]))); | |
74 | }); | |
75 | }); | |
76 | ||
77 | describe(`Int64`, () => { | |
78 | test(`gets expected high/low bytes`, () => { | |
79 | let i = new Int64(new Uint32Array([5, 0])); | |
80 | expect(i.high()).toEqual(0); | |
81 | expect(i.low()).toEqual(5); | |
82 | }); | |
83 | test(`adds 32-bit numbers`, () => { | |
84 | let a = new Int64(new Uint32Array([5, 0])); | |
85 | let b = new Int64(new Uint32Array([9, 0])); | |
86 | let expected = new Int64(new Uint32Array([14, 0])); | |
87 | expect(a.plus(b)).toEqual(expected); | |
88 | }); | |
89 | test(`adds negative 32-bit numbers`, () => { | |
90 | let a = new Int64(new Uint32Array([56789 , 0])); | |
91 | let b = new Int64(new Uint32Array([-66789, -1])); | |
92 | let expected = new Int64(new Uint32Array([-10000, -1])); | |
93 | expect(a.plus(b)).toEqual(expected); | |
94 | }); | |
95 | test(`addition overflows 32-bit numbers`, () => { | |
96 | let a = new Int64(new Uint32Array([0xffffffff, 0])); | |
97 | let b = new Int64(new Uint32Array([9, 0])); | |
98 | let expected = new Int64(new Uint32Array([8, 1])); | |
99 | expect(a.plus(b)).toEqual(expected); | |
100 | }); | |
101 | test(`multiplies 32-bit numbers`, () => { | |
102 | let a = new Int64(new Uint32Array([5, 0])); | |
103 | let b = new Int64(new Uint32Array([9, 0])); | |
104 | let expected = new Int64(new Uint32Array([45, 0])); | |
105 | expect(a.times(b)).toEqual(expected); | |
106 | }); | |
107 | test(`multiplication overflows 32-bit numbers`, () => { | |
108 | let a = new Int64(new Uint32Array([0x80000000, 0])); | |
109 | let b = new Int64(new Uint32Array([3, 0])); | |
110 | let expected = new Int64(new Uint32Array([0x80000000, 1])); | |
111 | expect(a.times(b)).toEqual(expected); | |
112 | }); | |
113 | test(`multiplication works on negative numbers`, () => { | |
114 | let a = new Int64(new Uint32Array([-5, -1])); | |
115 | let b = new Int64(new Uint32Array([-100, -1])); | |
116 | expect(a.times(b)).toEqual(new Int64(new Uint32Array([ 500, 0]))); | |
117 | expect(a.times(b)).toEqual(new Int64(new Uint32Array([ -50000, -1]))); | |
118 | expect(a.times(b)).toEqual(new Int64(new Uint32Array([5000000, 0]))); | |
119 | }); | |
120 | test(`multiplication is associative`, () => { | |
121 | let a = new Int64(new Uint32Array([0x80000000, 0])); | |
122 | let b = new Int64(new Uint32Array([3, 0])); | |
123 | expect(Int64.multiply(a, b)).toEqual(Int64.multiply(b,a)); | |
124 | }); | |
125 | test(`lessThan works on 32-bit numbers`, () => { | |
126 | let a = new Int64(new Uint32Array([0x0000abcd, 0])); | |
127 | let b = new Int64(new Uint32Array([0x0000abcf, 0])); | |
128 | expect(a.lessThan(b)).toBeTruthy(); | |
129 | }); | |
130 | test(`lessThan works on 64-bit numbers`, () => { | |
131 | let a = new Int64(new Uint32Array([123, 32])); | |
132 | let b = new Int64(new Uint32Array([568, 32])); | |
133 | expect(a.lessThan(b)).toBeTruthy(); | |
134 | }); | |
135 | test(`lessThan works on negative numbers`, () => { | |
136 | let a = new Int64(new Uint32Array([0, -158])); | |
137 | let b = new Int64(new Uint32Array([-3, -1])); | |
138 | expect(a.lessThan(b)).toBeTruthy(); | |
139 | }); | |
140 | test(`lessThan works on mixed numbers`, () => { | |
141 | let a = new Int64(new Uint32Array([-3, -1])); | |
142 | let b = new Int64(new Uint32Array([ 0, 3])); | |
143 | expect(a.lessThan(b)).toBeTruthy(); | |
144 | }); | |
145 | test(`negate works on 32-bit number`, () => { | |
146 | expect (new Int64(new Uint32Array([123456, 0])).negate()).toEqual(new Int64(new Uint32Array([-123456, -1]))); | |
147 | }); | |
148 | test(`double negation is noop`, () => { | |
149 | let test = new Int64(new Uint32Array([6789, 12345])); | |
150 | let expected = new Int64(new Uint32Array([6789, 12345])); | |
151 | expect(test.negate().negate()).toEqual(expected); | |
152 | }); | |
153 | test(`negate works on 64-bit number`, () => { | |
154 | expect (new Int64(new Uint32Array([0xb74abf15, 0x62c])).negate()).toEqual(new Int64(new Uint32Array([0x48b540eb, 0xfffff9d3]))); | |
155 | }); | |
156 | test(`fromString parses string`, () => { | |
157 | expect(Int64.fromString('6789123456789')).toEqual(new Int64(new Uint32Array([0xb74abf15, 0x62c]))); | |
158 | }); | |
159 | test(`fromString parses negative string`, () => { | |
160 | expect(Int64.fromString('-6789123456789')).toEqual(new Int64(new Uint32Array([0x48b540eb, 0xfffff9d3]))); | |
161 | }); | |
162 | test(`fromNumber converts 53-ish bit number`, () => { | |
163 | expect(Int64.fromNumber(8086463330923024)).toEqual(new Int64(new Uint32Array([0x76543210, 0x001cba98]))); | |
164 | expect(Int64.fromNumber(-8086463330923024)).toEqual(new Int64(new Uint32Array([0x89abcdf0, 0xffe34567]))); | |
165 | }); | |
166 | }); | |
167 | ||
168 | describe(`Int128`, () => { | |
169 | test(`gets expected bytes`, () => { | |
170 | let i = new Int128(new Uint32Array([4, 3, 2, 1])); | |
171 | expect(i.high().high()).toEqual(1); | |
172 | expect(i.high().low() ).toEqual(2); | |
173 | expect(i.low().high() ).toEqual(3); | |
174 | expect(i.low().low() ).toEqual(4); | |
175 | }); | |
176 | test(`adds 32-bit numbers`, () => { | |
177 | let a = new Int128(new Uint32Array([5, 0, 0, 0])); | |
178 | let b = new Int128(new Uint32Array([9, 0, 0, 0])); | |
179 | let expected = new Int128(new Uint32Array([14, 0, 0, 0])); | |
180 | expect(a.plus(b)).toEqual(expected); | |
181 | }); | |
182 | test(`adds negative 32-bit numbers`, () => { | |
183 | let a = new Int128(new Uint32Array([56789 , 0, 0, 0])); | |
184 | let b = new Int128(new Uint32Array([-66789, -1, -1, -1])); | |
185 | let expected = new Int128(new Uint32Array([-10000, -1, -1, -1])); | |
186 | expect(a.plus(b)).toEqual(expected); | |
187 | }); | |
188 | test(`addition overflows 32-bit numbers`, () => { | |
189 | let a = new Int128(new Uint32Array([0xffffffff, 0, 0, 0])); | |
190 | let b = new Int128(new Uint32Array([9, 0, 0, 0])); | |
191 | let expected = new Int128(new Uint32Array([8, 1, 0, 0])); | |
192 | expect(a.plus(b)).toEqual(expected); | |
193 | }); | |
194 | test(`multiplies 32-bit numbers`, () => { | |
195 | let a = new Int128(new Uint32Array([5, 0, 0, 0])); | |
196 | let b = new Int128(new Uint32Array([9, 0, 0, 0])); | |
197 | let expected = new Int128(new Uint32Array([45, 0, 0, 0])); | |
198 | expect(a.times(b)).toEqual(expected); | |
199 | }); | |
200 | test(`multiplication overflows 32-bit numbers`, () => { | |
201 | let a = new Int128(new Uint32Array([0x80000000, 0, 0, 0])); | |
202 | let b = new Int128(new Uint32Array([3, 0, 0, 0])); | |
203 | let expected = new Int128(new Uint32Array([0x80000000, 1, 0, 0])); | |
204 | expect(a.times(b)).toEqual(expected); | |
205 | }); | |
206 | test(`multiplication works on negative numbers`, () => { | |
207 | let a = new Int128(new Uint32Array([-5, -1, -1, -1])); | |
208 | let b = new Int128(new Uint32Array([-100, -1, -1, -1])); | |
209 | expect(a.times(b)).toEqual(new Int128(new Uint32Array([ 500, 0, 0, 0]))); | |
210 | expect(a.times(b)).toEqual(new Int128(new Uint32Array([ -50000, -1, -1, -1]))); | |
211 | expect(a.times(b)).toEqual(new Int128(new Uint32Array([5000000, 0, 0, 0]))); | |
212 | }); | |
213 | test(`multiplication is associative`, () => { | |
214 | let a = new Int128(new Uint32Array([4, 3, 2, 1])); | |
215 | let b = new Int128(new Uint32Array([3, 0, 0, 0])); | |
216 | expect(Int128.multiply(a, b)).toEqual(Int128.multiply(b,a)); | |
217 | }); | |
218 | test(`multiplication can produce 128-bit number`, () => { | |
219 | let a = new Int128(new Uint32Array([0, 0xf0000000, 0, 0])); | |
220 | let b = new Int128(new Uint32Array([0, 0x10000000, 0, 0])); | |
221 | expect(a.times(b)).toEqual(new Int128(new Uint32Array([0x00000000, 0x00000000, 0x00000000, 0xf000000]))); | |
222 | }); | |
223 | test(`fromString parses string`, () => { | |
224 | expect(Int128.fromString('1002111867823618826746863804903129070')) | |
225 | .toEqual(new Int64(new Uint32Array([0x00c0ffee, | |
226 | 0x00c0ffee, | |
227 | 0x00c0ffee, | |
228 | 0x00c0ffee]))); | |
229 | }); | |
230 | test(`fromString parses negative string`, () => { | |
231 | expect(Int128.fromString('-12345678901234567890123456789012345678')) | |
232 | .toEqual(new Int64(new Uint32Array([0x21c70cb2, | |
233 | 0x3bb66faf, | |
234 | 0x0ffdccec, | |
235 | 0xf6b64f09]))); | |
236 | }); | |
237 | test(`fromNumber converts 53-ish bit number`, () => { | |
238 | expect(Int128.fromNumber(8086463330923024)).toEqual(new Int128(new Uint32Array([0x76543210, 0x001cba98, 0, 0]))); | |
239 | expect(Int128.fromNumber(-8086463330923024)).toEqual(new Int128(new Uint32Array([0x89abcdf0, 0xffe34567, 0xffffffff, 0xffffffff]))); | |
240 | }); | |
241 | }); |