| // Protocol Buffers - Google's data interchange format |
| // Copyright 2008 Google Inc. All rights reserved. |
| // https://protobuf.dev/ |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| /** |
| * @fileoverview Test cases for Int64-manipulation functions. |
| * |
| * Test suite is written using Jasmine -- see http://jasmine.github.io/ |
| * |
| * @author [email protected] (Chris Fallin) |
| */ |
| |
| goog.require('jspb.arith.Int64'); |
| goog.require('jspb.arith.UInt64'); |
| |
| const Int64 = goog.module.get('jspb.arith').Int64; |
| const UInt64 = goog.module.get('jspb.arith').UInt64; |
| |
| |
| describe('binaryArithTest', () => { |
| describe('UInt64', () => { |
| const /** ReadonlyArray<[number, number, string]> */ testData = Object.freeze([ |
| [0x0, 0x0, '0'], |
| [0xffffffff, 0xffffffff, '18446744073709551615'], |
| [0xffffffff, 0x00000000, '4294967295'], |
| [0x00000000, 0xffffffff, '18446744069414584320'], |
| [0x000f4240, 0x00000000, '1000000'], |
| [0x000f423f, 0x00000000, '999999'], |
| [0xd4a51000, 0x0000000e8, '1000000000000'], |
| [0xd4a50fff, 0x0000000e8, '999999999999'], |
| [0x5e84c935, 0xcae33d0e, '14619595947299359029'], |
| [0x62b3b8b8, 0x93480544, '10612738313170434232'], |
| [0x319bfb13, 0xc01c4172, '13843011313344445203'], |
| [0x5b8a65fb, 0xa5885b31, '11927883880638080507'], |
| [0x6bdb80f1, 0xb0d1b16b, '12741159895737008369'], |
| [0x4b82b442, 0x2e0d8c97, '3318463081876730946'], |
| [0x780d5208, 0x7d76752c, '9040542135845999112'], |
| [0x2e46800f, 0x0993778d, '690026616168284175'], |
| [0xf00a7e32, 0xcd8e3931, '14811839111111540274'], |
| [0x1baeccd6, 0x923048c4, '10533999535534820566'], |
| [0x03669d29, 0xbff3ab72, '13831587386756603177'], |
| [0x2526073e, 0x01affc81, '121593346566522686'], |
| [0xc24244e0, 0xd7f40d0e, '15561076969511732448'], |
| [0xc56a341e, 0xa68b66a7, '12000798502816461854'], |
| [0x8738d64d, 0xbfe78604, '13828168534871037517'], |
| [0x5baff03b, 0xd7572aea, '15516918227177304123'], |
| [0x4a843d8a, 0x864e132b, '9677693725920476554'], |
| [0x25b4e94d, 0x22b54dc6, '2500990681505655117'], |
| [0x6bbe664b, 0x55a5cc0e, '6171563226690381387'], |
| [0xee916c81, 0xb00aabb3, '12685140089732426881'], |
| ]); |
| |
| // If BigInt is available, verify our test data with that. |
| if (typeof BigInt !== 'undefined') { |
| it('is tested with valid test data as verified with BigInt', () => { |
| for (const testCase of testData) { |
| const big = (BigInt(testCase[1]) << BigInt(32)) + BigInt(testCase[0]); |
| expect(big.toString()).toEqual(testCase[2]); |
| } |
| }); |
| |
| describe('fromBigInt', () => { |
| it(`parses testData`, () => { |
| for (const testCase of testData) { |
| const roundtrip = UInt64.fromBigInt(BigInt(testCase[2])); |
| expect(roundtrip.lo).withContext(testCase[2]).toEqual(testCase[0]); |
| expect(roundtrip.hi).withContext(testCase[2]).toEqual(testCase[1]); |
| } |
| }); |
| }); |
| } |
| |
| describe('toDecimalString', () => { |
| it(`serializes testData`, () => { |
| for (const testCase of testData) { |
| const a = new UInt64(testCase[0], testCase[1]); |
| const actualString = a.toDecimalString(); |
| expect(actualString).withContext(testCase[2]).toEqual(testCase[2]); |
| } |
| }); |
| }); |
| |
| describe('fromString', () => { |
| it(`parses testData`, () => { |
| for (const testCase of testData) { |
| const roundtrip = UInt64.fromString(testCase[2]); |
| expect(roundtrip.lo).withContext(testCase[2]).toEqual(testCase[0]); |
| expect(roundtrip.hi).withContext(testCase[2]).toEqual(testCase[1]); |
| } |
| }); |
| |
| it('parses empty string as zero', () => { |
| expect(UInt64.fromString('')).toEqual(UInt64.fromString('0')); |
| }); |
| |
| it('does not parse non-decimal strings', () => { |
| expect(UInt64.fromString('0x123')).toBeNull(); |
| expect(UInt64.fromString(' 123')).toBeNull(); |
| }); |
| |
| it('tolerates extra leading zeros', () => { |
| expect(UInt64.fromString('0018446744073709551615')).toEqual( |
| UInt64.fromString('18446744073709551615'), |
| ); |
| }); |
| |
| it('truncates values that are too big', () => { |
| // 0x1_FFFF_FFFF_FFFF_FFFF = 36893488147419103231 |
| // 0xFFFF_FFFF_FFFF_FFFF = 18446744073709551615 |
| expect(UInt64.fromString('36893488147419103231')).toEqual( |
| UInt64.fromString('18446744073709551615'), |
| ); |
| }); |
| }); |
| |
| describe('negateInTwosComplement', () => { |
| if (typeof BigInt !== 'undefined') { |
| it('produces correct values', () => { |
| for (const testCase of testData) { |
| if (testCase[0] === 0 && testCase[1] === 0) continue; |
| const result = new UInt64( |
| testCase[0], |
| testCase[1], |
| ).negateInTwosComplement(); |
| const resultBigInt = |
| (BigInt(result.hi) << BigInt(32)) + BigInt(result.lo); |
| const expected = |
| (BigInt(1) << BigInt(64)) - |
| ((BigInt(testCase[1]) << BigInt(32)) + BigInt(testCase[0])); |
| expect(resultBigInt).toEqual(expected); |
| } |
| }); |
| } |
| |
| it('round-trips', () => { |
| for (const testCase of testData) { |
| expect( |
| new UInt64(testCase[0], testCase[1]) |
| .negateInTwosComplement() |
| .negateInTwosComplement() |
| .toDecimalString(), |
| ).toBe(testCase[2]); |
| } |
| }); |
| }); |
| }); |
| |
| describe('Int64', () => { |
| const /** ReadonlyArray<[number, number, string]> */ testData = Object.freeze([ |
| [0x0, 0x0, '0'], |
| [0xffffffff, 0xffffffff, '-1'], |
| [0x00000000, 0x80000000, '-9223372036854775808'], |
| [0xffffffff, 0x3fffffff, '4611686018427387903'], |
| [0xffffffff, 0x00000000, '4294967295'], |
| [0x00000000, 0xffffffff, '-4294967296'], |
| [0x000f4240, 0x00000000, '1000000'], |
| [0xd4a51000, 0x0000000e8, '1000000000000'], |
| [0xc5bb087e, 0x931814a6, '-7847499644178593666'], |
| [0xb58a5643, 0x3458a55b, '3771946501229139523'], |
| [0x7113da74, 0x27de6fcf, '2872856549054995060'], |
| [0x9d22f8c8, 0xafc92384, '-5780049594274350904'], |
| [0x48c45eb1, 0x2ef59f66, '3383785956695105201'], |
| [0x4f0a03e2, 0x294269f0, '2973055184857072610'], |
| [0xd4e95c3a, 0xca29805e, '-3879428459215627206'], |
| [0x934049d7, 0x3fb24a16, '4589812431064156631'], |
| [0xd272e654, 0x75bd7dc4, '8484075557333689940'], |
| [0x21f03f77, 0xeec5322, '1075325817098092407'], |
| [0x12158d26, 0xc3ad6da7, '-4346697501012292314'], |
| [0x7247925d, 0x22895b1f, '2488620459718316637'], |
| [0xb8d3e7a0, 0x54d48381, '6112655187423520672'], |
| [0xbf4836f8, 0xcd45d7c6, '-3655278273928612104'], |
| [0xf853f23c, 0x2fba545b, '3439154019435803196'], |
| [0xc004fc2d, 0xdef52fa, '1004112478843763757'], |
| [0x394e4b63, 0xa4937731, '-6587790776614368413'], |
| [0x596ed01a, 0x09382394, '664320065099714586'], |
| [0xe3244770, 0x42106251, '4760412909973292912'], |
| [0x92c2b290, 0x9233453d, '-7911903989602274672'], |
| ]); |
| |
| // If BigInt is available, verify our test data with that. |
| if (typeof BigInt !== 'undefined') { |
| it('is tested with valid test data as verified with BigInt', () => { |
| for (const testCase of testData) { |
| let big = (BigInt(testCase[1]) << BigInt(32)) + BigInt(testCase[0]); |
| if (testCase[2][0] === '-') { |
| big -= BigInt(2 ** 64); |
| } |
| expect(big.toString()).toEqual(testCase[2]); |
| } |
| }); |
| |
| describe('fromBigInt', () => { |
| it(`parses testData`, () => { |
| for (const testCase of testData) { |
| const roundtrip = Int64.fromBigInt(BigInt(testCase[2])); |
| expect(roundtrip.lo).withContext(testCase[2]).toEqual(testCase[0]); |
| expect(roundtrip.hi).withContext(testCase[2]).toEqual(testCase[1]); |
| } |
| }); |
| }); |
| } |
| |
| describe('toDecimalString', () => { |
| it(`serializes testData`, () => { |
| for (const testCase of testData) { |
| const a = new Int64(testCase[0], testCase[1]); |
| const actualString = a.toDecimalString(); |
| expect(actualString).withContext(testCase[2]).toEqual(testCase[2]); |
| } |
| }); |
| }); |
| |
| describe('fromString', () => { |
| it(`parses testData`, () => { |
| for (const testCase of testData) { |
| const roundtrip = Int64.fromString(testCase[2]); |
| expect(roundtrip.lo).withContext(testCase[2]).toEqual(testCase[0]); |
| expect(roundtrip.hi).withContext(testCase[2]).toEqual(testCase[1]); |
| } |
| }); |
| |
| it('parses empty string as zero', () => { |
| expect(Int64.fromString('')).toEqual(Int64.fromString('0')); |
| }); |
| |
| it('parses -0 string as zero', () => { |
| expect(Int64.fromString('-0')).toEqual(Int64.fromString('0')); |
| }); |
| |
| it('parses positive values that overflow into the negative space', () => { |
| expect( |
| Int64.fromString('9223372036854775808')?.toDecimalString(), |
| ).toEqual('-9223372036854775808'); |
| }); |
| |
| it('truncates values that are too big', () => { |
| // 0x1_FFFF_FFFF_FFFF_FFFF = 36893488147419103231 |
| // 0xFFFF_FFFF_FFFF_FFFF = 18446744073709551615 |
| expect(Int64.fromString('36893488147419103231')).toEqual( |
| Int64.fromString('18446744073709551615'), |
| ); |
| }); |
| |
| it('does not parse non-decimal strings', () => { |
| expect(Int64.fromString('0x123')).toBeNull(); |
| expect(Int64.fromString(' 123')).toBeNull(); |
| }); |
| }); |
| }); |
| }); |
