protobuf/js/experimental/runtime/int64_test.js

/**
 * @fileoverview Tests for Int64.
 */
goog.module('protobuf.Int64Test');
goog.setTestOnly();

const Int64 = goog.require('protobuf.Int64');
const Long = goog.require('goog.math.Long');

describe('Int64', () => {
  it('can be constructed from bits', () => {
    const int64 = Int64.fromBits(0, 1);
    expect(int64.getLowBits()).toEqual(0);
    expect(int64.getHighBits()).toEqual(1);
  });

  it('zero is defined', () => {
    const int64 = Int64.getZero();
    expect(int64.getLowBits()).toEqual(0);
    expect(int64.getHighBits()).toEqual(0);
  });

  it('max value is defined', () => {
    const int64 = Int64.getMaxValue();
    expect(int64).toEqual(Int64.fromBits(0xFFFFFFFF, 0x7FFFFFFF));
    expect(int64.asLong()).toEqual(Long.getMaxValue());
  });

  it('min value is defined', () => {
    const int64 = Int64.getMinValue();
    expect(int64).toEqual(Int64.fromBits(0, 0x80000000));
    expect(int64.asLong()).toEqual(Long.getMinValue());
  });

  it('Can be converted to long', () => {
    const int64 = Int64.fromInt(1);
    expect(int64.asLong()).toEqual(Long.fromInt(1));
  });

  it('Negative value can be converted to long', () => {
    const int64 = Int64.fromInt(-1);
    expect(int64.getLowBits()).toEqual(0xFFFFFFFF | 0);
    expect(int64.getHighBits()).toEqual(0xFFFFFFFF | 0);
    expect(int64.asLong()).toEqual(Long.fromInt(-1));
  });

  it('Can be converted to number', () => {
    const int64 = Int64.fromInt(1);
    expect(int64.asNumber()).toEqual(1);
  });

  it('Can convert negative value to number', () => {
    const int64 = Int64.fromInt(-1);
    expect(int64.asNumber()).toEqual(-1);
  });

  it('MAX_SAFE_INTEGER can be used.', () => {
    const int64 = Int64.fromNumber(Number.MAX_SAFE_INTEGER);
    expect(int64.getLowBitsUnsigned()).toEqual(0xFFFFFFFF);
    expect(int64.getHighBits()).toEqual(0x1FFFFF);
    expect(int64.asNumber()).toEqual(Number.MAX_SAFE_INTEGER);
  });

  it('MIN_SAFE_INTEGER can be used.', () => {
    const int64 = Int64.fromNumber(Number.MIN_SAFE_INTEGER);
    expect(int64.asNumber()).toEqual(Number.MIN_SAFE_INTEGER);
  });

  it('constructs fromInt', () => {
    const int64 = Int64.fromInt(1);
    expect(int64.getLowBits()).toEqual(1);
    expect(int64.getHighBits()).toEqual(0);
  });

  it('constructs fromLong', () => {
    const int64 = Int64.fromLong(Long.fromInt(1));
    expect(int64.getLowBits()).toEqual(1);
    expect(int64.getHighBits()).toEqual(0);
  });

  // TODO: Use our own checking system here.
  if (goog.DEBUG) {
    it('asNumber throws for MAX_SAFE_INTEGER + 1', () => {
      expect(() => Int64.fromNumber(Number.MAX_SAFE_INTEGER + 1).asNumber())
          .toThrow();
    });

    it('fromInt(MAX_SAFE_INTEGER) throws', () => {
      expect(() => Int64.fromInt(Number.MAX_SAFE_INTEGER)).toThrow();
    });

    it('fromInt(1.5) throws', () => {
      expect(() => Int64.fromInt(1.5)).toThrow();
    });
  }

  const decimalHexPairs = {
    '0x0000000000000000': {signed: '0'},
    '0x0000000000000001': {signed: '1'},
    '0x00000000ffffffff': {signed: '4294967295'},
    '0x0000000100000000': {signed: '4294967296'},
    '0xffffffffffffffff': {signed: '-1', unsigned: '18446744073709551615'},
    '0x8000000000000000':
        {signed: '-9223372036854775808', unsigned: '9223372036854775808'},
    '0x8000000080000000':
        {signed: '-9223372034707292160', unsigned: '9223372039002259456'},
    '0x01b69b4bacd05f15': {signed: '123456789123456789'},
    '0xfe4964b4532fa0eb':
        {signed: '-123456789123456789', unsigned: '18323287284586094827'},
    '0xa5a5a5a5a5a5a5a5':
        {signed: '-6510615555426900571', unsigned: '11936128518282651045'},
    '0x5a5a5a5a5a5a5a5a': {signed: '6510615555426900570'},
    '0xffffffff00000000':
        {signed: '-4294967296', unsigned: '18446744069414584320'},
  };

  it('serializes to signed decimal strings', () => {
    for (const [hex, decimals] of Object.entries(decimalHexPairs)) {
      const int64 = hexToInt64(hex);
      expect(int64.toSignedDecimalString()).toEqual(decimals.signed);
    }
  });

  it('serializes to unsigned decimal strings', () => {
    for (const [hex, decimals] of Object.entries(decimalHexPairs)) {
      const int64 = hexToInt64(hex);
      expect(int64.toUnsignedDecimalString())
          .toEqual(decimals.unsigned || decimals.signed);
    }
  });

  it('serializes to unsigned hex strings', () => {
    for (const [hex, decimals] of Object.entries(decimalHexPairs)) {
      const int64 = hexToInt64(hex);
      let shortHex = hex.replace(/0x0*/, '0x');
      if (shortHex == '0x') {
        shortHex = '0x0';
      }
      expect(int64.toHexString()).toEqual(shortHex);
    }
  });

  it('parses decimal strings', () => {
    for (const [hex, decimals] of Object.entries(decimalHexPairs)) {
      const signed = Int64.fromDecimalString(decimals.signed);
      expect(int64ToHex(signed)).toEqual(hex);
      if (decimals.unsigned) {
        const unsigned = Int64.fromDecimalString(decimals.unsigned);
        expect(int64ToHex(unsigned)).toEqual(hex);
      }
    }
  });

  it('parses hex strings', () => {
    for (const [hex, decimals] of Object.entries(decimalHexPairs)) {
      expect(int64ToHex(Int64.fromHexString(hex))).toEqual(hex);
    }
    expect(int64ToHex(Int64.fromHexString('-0x1')))
        .toEqual('0xffffffffffffffff');
  });

  // TODO: Use our own checking system here.
  if (goog.DEBUG) {
    it('throws when parsing empty string', () => {
      expect(() => Int64.fromDecimalString('')).toThrow();
    });

    it('throws when parsing float string', () => {
      expect(() => Int64.fromDecimalString('1.5')).toThrow();
    });

    it('throws when parsing non-numeric string', () => {
      expect(() => Int64.fromDecimalString('0xa')).toThrow();
    });
  }

  it('checks if equal', () => {
    const low = Int64.fromInt(1);
    const high = Int64.getMaxValue();
    expect(low.equals(Int64.fromInt(1))).toEqual(true);
    expect(low.equals(high)).toEqual(false);
    expect(high.equals(Int64.getMaxValue())).toEqual(true);
  });

  it('returns unique hashcode', () => {
    expect(Int64.fromInt(1).hashCode()).toEqual(Int64.fromInt(1).hashCode());
    expect(Int64.fromInt(1).hashCode())
        .not.toEqual(Int64.fromInt(2).hashCode());
  });
});

/**
 * @param {string} hexString
 * @return {!Int64}
 */
function hexToInt64(hexString) {
  const high = hexString.slice(2, 10);
  const low = hexString.slice(10);
  return Int64.fromBits(parseInt(low, 16), parseInt(high, 16));
}

/**
 * @param {!Int64} int64
 * @return {string}
 */
function int64ToHex(int64) {
  const ZEROS_32_BIT = '00000000';
  const highPartialHex = int64.getHighBitsUnsigned().toString(16);
  const lowPartialHex = int64.getLowBitsUnsigned().toString(16);
  const highHex = ZEROS_32_BIT.slice(highPartialHex.length) + highPartialHex;
  const lowHex = ZEROS_32_BIT.slice(lowPartialHex.length) + lowPartialHex;
  return `0x${highHex}${lowHex}`;
}