// 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.

// Test suite is written using Jasmine -- see http://jasmine.github.io/

goog.require('goog.crypt.base64');

goog.require('jspb.BinaryWriter');
goog.require('jspb.Message');

// CommonJS-LoadFromFile: ../protos/testbinary_pb proto.jspb.test
goog.require('proto.jspb.test.ExtendsWithMessage');
goog.require('proto.jspb.test.ForeignEnum');
goog.require('proto.jspb.test.ForeignMessage');
goog.require('proto.jspb.test.TestAllTypes');
goog.require('proto.jspb.test.TestExtendable');
goog.require('proto.jspb.test.extendOptionalBool');
goog.require('proto.jspb.test.extendOptionalBytes');
goog.require('proto.jspb.test.extendOptionalDouble');
goog.require('proto.jspb.test.extendOptionalFixed32');
goog.require('proto.jspb.test.extendOptionalFixed64');
goog.require('proto.jspb.test.extendOptionalFloat');
goog.require('proto.jspb.test.extendOptionalForeignEnum');
goog.require('proto.jspb.test.extendOptionalInt32');
goog.require('proto.jspb.test.extendOptionalInt64');
goog.require('proto.jspb.test.extendOptionalSfixed32');
goog.require('proto.jspb.test.extendOptionalSfixed64');
goog.require('proto.jspb.test.extendOptionalSint32');
goog.require('proto.jspb.test.extendOptionalSint64');
goog.require('proto.jspb.test.extendOptionalString');
goog.require('proto.jspb.test.extendOptionalUint32');
goog.require('proto.jspb.test.extendOptionalUint64');
goog.require('proto.jspb.test.extendPackedRepeatedBoolList');
goog.require('proto.jspb.test.extendPackedRepeatedDoubleList');
goog.require('proto.jspb.test.extendPackedRepeatedFixed32List');
goog.require('proto.jspb.test.extendPackedRepeatedFixed64List');
goog.require('proto.jspb.test.extendPackedRepeatedFloatList');
goog.require('proto.jspb.test.extendPackedRepeatedForeignEnumList');
goog.require('proto.jspb.test.extendPackedRepeatedInt32List');
goog.require('proto.jspb.test.extendPackedRepeatedInt64List');
goog.require('proto.jspb.test.extendPackedRepeatedSfixed32List');
goog.require('proto.jspb.test.extendPackedRepeatedSfixed64List');
goog.require('proto.jspb.test.extendPackedRepeatedSint32List');
goog.require('proto.jspb.test.extendPackedRepeatedSint64List');
goog.require('proto.jspb.test.extendPackedRepeatedUint32List');
goog.require('proto.jspb.test.extendPackedRepeatedUint64List');
goog.require('proto.jspb.test.extendRepeatedBoolList');
goog.require('proto.jspb.test.extendRepeatedBytesList');
goog.require('proto.jspb.test.extendRepeatedDoubleList');
goog.require('proto.jspb.test.extendRepeatedFixed32List');
goog.require('proto.jspb.test.extendRepeatedFixed64List');
goog.require('proto.jspb.test.extendRepeatedFloatList');
goog.require('proto.jspb.test.extendRepeatedForeignEnumList');
goog.require('proto.jspb.test.extendRepeatedInt32List');
goog.require('proto.jspb.test.extendRepeatedInt64List');
goog.require('proto.jspb.test.extendRepeatedSfixed32List');
goog.require('proto.jspb.test.extendRepeatedSfixed64List');
goog.require('proto.jspb.test.extendRepeatedSint32List');
goog.require('proto.jspb.test.extendRepeatedSint64List');
goog.require('proto.jspb.test.extendRepeatedStringList');
goog.require('proto.jspb.test.extendRepeatedUint32List');
goog.require('proto.jspb.test.extendRepeatedUint64List');

// clang-format off
// CommonJS-LoadFromFile: ../node_modules/google-protobuf/google/protobuf/any_pb proto.google.protobuf
goog.require('proto.google.protobuf.Any');


const suite = {};

const BYTES = new Uint8Array([1, 2, 8, 9]);

const BYTES_B64 = goog.crypt.base64.encodeByteArray(BYTES);


/**
 * Helper: fill all fields on a TestAllTypes message.
 * @param {proto.jspb.test.TestAllTypes} msg
 */
function fillAllFields(msg) {
  msg.setOptionalInt32(-42);
  // can be exactly represented by JS number (64-bit double, i.e., 52-bit
  // mantissa).
  msg.setOptionalInt64(-0x7fffffff00000000);
  msg.setOptionalUint32(0x80000000);
  msg.setOptionalUint64(0xf000000000000000);
  msg.setOptionalSint32(-100);
  msg.setOptionalSint64(-0x8000000000000000);
  msg.setOptionalFixed32(1234);
  msg.setOptionalFixed64(0x1234567800000000);
  msg.setOptionalSfixed32(-1234);
  msg.setOptionalSfixed64(-0x1234567800000000);
  msg.setOptionalFloat(1.5);
  msg.setOptionalDouble(-1.5);
  msg.setOptionalBool(true);
  msg.setOptionalString('hello world');
  msg.setOptionalBytes(BYTES);
  msg.setOptionalGroup(new proto.jspb.test.TestAllTypes.OptionalGroup());
  msg.getOptionalGroup().setA(100);
  let submsg = new proto.jspb.test.ForeignMessage();
  submsg.setC(16);
  msg.setOptionalForeignMessage(submsg);
  msg.setOptionalForeignEnum(proto.jspb.test.ForeignEnum.FOREIGN_FOO);
  msg.setOneofString('oneof');


  msg.setRepeatedInt32List([-42]);
  msg.setRepeatedInt64List([-0x7fffffff00000000]);
  msg.setRepeatedUint32List([0x80000000]);
  msg.setRepeatedUint64List([0xf000000000000000]);
  msg.setRepeatedSint32List([-100]);
  msg.setRepeatedSint64List([-0x8000000000000000]);
  msg.setRepeatedFixed32List([1234]);
  msg.setRepeatedFixed64List([0x1234567800000000]);
  msg.setRepeatedSfixed32List([-1234]);
  msg.setRepeatedSfixed64List([-0x1234567800000000]);
  msg.setRepeatedFloatList([1.5]);
  msg.setRepeatedDoubleList([-1.5]);
  msg.setRepeatedBoolList([true]);
  msg.setRepeatedStringList(['hello world']);
  msg.setRepeatedBytesList([BYTES, BYTES]);
  msg.setRepeatedGroupList([new proto.jspb.test.TestAllTypes.RepeatedGroup()]);
  msg.getRepeatedGroupList()[0].setA(100);
  submsg = new proto.jspb.test.ForeignMessage();
  submsg.setC(1000);
  msg.setRepeatedForeignMessageList([submsg]);
  msg.setRepeatedForeignEnumList([proto.jspb.test.ForeignEnum.FOREIGN_FOO]);

  msg.setPackedRepeatedInt32List([-42]);
  msg.setPackedRepeatedInt64List([-0x7fffffff00000000]);
  msg.setPackedRepeatedUint32List([0x80000000]);
  msg.setPackedRepeatedUint64List([0xf000000000000000]);
  msg.setPackedRepeatedSint32List([-100]);
  msg.setPackedRepeatedSint64List([-0x8000000000000000]);
  msg.setPackedRepeatedFixed32List([1234]);
  msg.setPackedRepeatedFixed64List([0x1234567800000000]);
  msg.setPackedRepeatedSfixed32List([-1234]);
  msg.setPackedRepeatedSfixed64List([-0x1234567800000000]);
  msg.setPackedRepeatedFloatList([1.5]);
  msg.setPackedRepeatedDoubleList([-1.5]);
  msg.setPackedRepeatedBoolList([true]);
}


/**
 * Helper: compare a bytes field to an expected value
 * @param {Uint8Array|string} arr
 * @param {Uint8Array} expected
 * @return {boolean}
 */
function bytesCompare(arr, expected) {
  if (typeof arr === 'string') {
    arr = goog.crypt.base64.decodeStringToUint8Array(arr);
  }
  if (arr.length != expected.length) {
    return false;
  }
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] != expected[i]) {
      return false;
    }
  }
  return true;
}


/**
 * Helper: verify contents of given TestAllTypes message as set by
 * fillAllFields().
 * @param {proto.jspb.test.TestAllTypes} original
 * @param {proto.jspb.test.TestAllTypes} copy
 */
function checkAllFields(original, copy) {
  expect(copy.getOptionalInt32()).toEqual(-42);
  expect(copy.getOptionalInt64()).toEqual(-0x7fffffff00000000);
  expect(copy.getOptionalUint32()).toEqual(0x80000000);
  expect(copy.getOptionalUint64()).toEqual(0xf000000000000000);
  expect(copy.getOptionalSint32()).toEqual(-100);
  expect(copy.getOptionalSint64()).toEqual(-0x8000000000000000);
  expect(copy.getOptionalFixed32()).toEqual(1234);
  expect(copy.getOptionalFixed64()).toEqual(0x1234567800000000);
  expect(copy.getOptionalSfixed32()).toEqual(-1234);
  expect(copy.getOptionalSfixed64()).toEqual(-0x1234567800000000);
  expect(copy.getOptionalFloat()).toEqual(1.5);
  expect(copy.getOptionalDouble()).toEqual(-1.5);
  expect(copy.getOptionalBool()).toBeTrue();
  expect(copy.getOptionalString()).toEqual('hello world');
  expect(bytesCompare(copy.getOptionalBytes(), BYTES)).toEqual(true);
  expect(true).toEqual(bytesCompare(copy.getOptionalBytes_asU8(), BYTES));
  expect(copy.getOptionalBytes_asB64())
      .toEqual(goog.crypt.base64.encodeByteArray(BYTES));

  expect(copy.getOptionalGroup().getA()).toEqual(100);
  expect(copy.getOptionalForeignMessage().getC()).toEqual(16);
  expect(proto.jspb.test.ForeignEnum.FOREIGN_FOO)
      .toEqual(copy.getOptionalForeignEnum());


  expect(copy.getOneofString()).toEqual('oneof');
  expect(proto.jspb.test.TestAllTypes.OneofFieldCase.ONEOF_STRING)
      .toEqual(copy.getOneofFieldCase());

  expect(copy.getRepeatedInt32List()).toEqual([-42]);
  expect(copy.getRepeatedInt64List()).toEqual([-0x7fffffff00000000]);
  expect(copy.getRepeatedUint32List()).toEqual([0x80000000]);
  expect(copy.getRepeatedUint64List()).toEqual([0xf000000000000000]);
  expect(copy.getRepeatedSint32List()).toEqual([-100]);
  expect(copy.getRepeatedSint64List()).toEqual([-0x8000000000000000]);
  expect(copy.getRepeatedFixed32List()).toEqual([1234]);
  expect(copy.getRepeatedFixed64List()).toEqual([0x1234567800000000]);
  expect(copy.getRepeatedSfixed32List()).toEqual([-1234]);
  expect(copy.getRepeatedSfixed64List()).toEqual([-0x1234567800000000]);
  expect(copy.getRepeatedFloatList()).toEqual([1.5]);
  expect(copy.getRepeatedDoubleList()).toEqual([-1.5]);
  expect(copy.getRepeatedBoolList()).toEqual([true]);
  expect(copy.getRepeatedStringList()).toEqual(['hello world']);
  expect(copy.getRepeatedBytesList().length).toEqual(2);
  expect(true).toEqual(
      bytesCompare(copy.getRepeatedBytesList_asU8()[0], BYTES));
  expect(true).toEqual(bytesCompare(copy.getRepeatedBytesList()[0], BYTES));
  expect(true).toEqual(
      bytesCompare(copy.getRepeatedBytesList_asU8()[1], BYTES));
  expect(copy.getRepeatedBytesList_asB64()[0]).toEqual(BYTES_B64);
  expect(copy.getRepeatedBytesList_asB64()[1]).toEqual(BYTES_B64);
  expect(copy.getRepeatedGroupList().length).toEqual(1);
  expect(copy.getRepeatedGroupList()[0].getA()).toEqual(100);
  expect(copy.getRepeatedForeignMessageList().length).toEqual(1);
  expect(copy.getRepeatedForeignMessageList()[0].getC()).toEqual(1000);
  expect([
    proto.jspb.test.ForeignEnum.FOREIGN_FOO
  ]).toEqual(copy.getRepeatedForeignEnumList());

  expect(copy.getPackedRepeatedInt32List()).toEqual([-42]);
  expect(copy.getPackedRepeatedInt64List()).toEqual([-0x7fffffff00000000]);
  expect(copy.getPackedRepeatedUint32List()).toEqual([0x80000000]);
  expect(copy.getPackedRepeatedUint64List()).toEqual([0xf000000000000000]);
  expect(copy.getPackedRepeatedSint32List()).toEqual([-100]);
  expect(copy.getPackedRepeatedSint64List()).toEqual([-0x8000000000000000]);
  expect(copy.getPackedRepeatedFixed32List()).toEqual([1234]);
  expect(copy.getPackedRepeatedFixed64List()).toEqual([0x1234567800000000]);
  expect(copy.getPackedRepeatedSfixed32List()).toEqual([-1234]);
  expect(copy.getPackedRepeatedSfixed64List()).toEqual([-0x1234567800000000]);
  expect(copy.getPackedRepeatedFloatList()).toEqual([1.5]);
  expect(copy.getPackedRepeatedDoubleList()).toEqual([-1.5]);


  // Check last so we get more granular errors first.
  expect(jspb.Message.equals(original, copy)).toBeTrue();
}


/**
 * Helper: verify that all expected extensions are present.
 * @param {!proto.jspb.test.TestExtendable} msg
 */
function checkExtensions(msg) {
  expect(0).toEqual(msg.getExtension(proto.jspb.test.extendOptionalInt32));
  expect(-0x7fffffff00000000)
      .toEqual(msg.getExtension(proto.jspb.test.extendOptionalInt64));
  expect(0x80000000)
      .toEqual(msg.getExtension(proto.jspb.test.extendOptionalUint32));
  expect(0xf000000000000000)
      .toEqual(msg.getExtension(proto.jspb.test.extendOptionalUint64));
  expect(-100).toEqual(msg.getExtension(proto.jspb.test.extendOptionalSint32));
  expect(-0x8000000000000000)
      .toEqual(msg.getExtension(proto.jspb.test.extendOptionalSint64));
  expect(1234).toEqual(msg.getExtension(proto.jspb.test.extendOptionalFixed32));
  expect(0x1234567800000000)
      .toEqual(msg.getExtension(proto.jspb.test.extendOptionalFixed64));
  expect(-1234).toEqual(
      msg.getExtension(proto.jspb.test.extendOptionalSfixed32));
  expect(-0x1234567800000000)
      .toEqual(msg.getExtension(proto.jspb.test.extendOptionalSfixed64));
  expect(msg.getExtension(proto.jspb.test.extendOptionalFloat)).toEqual(1.5);
  expect(msg.getExtension(proto.jspb.test.extendOptionalDouble)).toEqual(-1.5);
  expect(msg.getExtension(proto.jspb.test.extendOptionalBool)).toEqual(true);
  expect(msg.getExtension(proto.jspb.test.extendOptionalString))
      .toEqual('hello world');
  expect(bytesCompare(
             msg.getExtension(proto.jspb.test.extendOptionalBytes), BYTES))
      .toEqual(true);
  expect(msg.getExtension(proto.jspb.test.ExtendsWithMessage.optionalExtension)
             .getFoo())
      .toEqual(16);


  expect(msg.getExtension(proto.jspb.test.extendRepeatedInt32List)).toEqual([
    -42
  ]);
  expect(msg.getExtension(proto.jspb.test.extendRepeatedInt64List)).toEqual([
    -0x7fffffff00000000
  ]);
  expect(msg.getExtension(proto.jspb.test.extendRepeatedUint32List)).toEqual([
    0x80000000
  ]);
  expect(msg.getExtension(proto.jspb.test.extendRepeatedUint64List)).toEqual([
    0xf000000000000000
  ]);
  expect(msg.getExtension(proto.jspb.test.extendRepeatedSint32List)).toEqual([
    -100
  ]);
  expect(msg.getExtension(proto.jspb.test.extendRepeatedSint64List)).toEqual([
    -0x8000000000000000
  ]);
  expect(msg.getExtension(proto.jspb.test.extendRepeatedFixed32List)).toEqual([
    1234
  ]);
  expect(msg.getExtension(proto.jspb.test.extendRepeatedFixed64List)).toEqual([
    0x1234567800000000
  ]);
  expect(msg.getExtension(proto.jspb.test.extendRepeatedSfixed32List)).toEqual([
    -1234
  ]);
  expect(msg.getExtension(proto.jspb.test.extendRepeatedSfixed64List)).toEqual([
    -0x1234567800000000
  ]);
  expect(msg.getExtension(proto.jspb.test.extendRepeatedFloatList)).toEqual([
    1.5
  ]);
  expect(msg.getExtension(proto.jspb.test.extendRepeatedDoubleList)).toEqual([
    -1.5
  ]);
  expect(msg.getExtension(proto.jspb.test.extendRepeatedBoolList)).toEqual([
    true
  ]);
  expect(msg.getExtension(proto.jspb.test.extendRepeatedStringList)).toEqual([
    'hello world'
  ]);
  expect(true).toEqual(bytesCompare(
      msg.getExtension(proto.jspb.test.extendRepeatedBytesList)[0], BYTES));
  expect(1000).toEqual(
      msg.getExtension(
             proto.jspb.test.ExtendsWithMessage.repeatedExtensionList)[0]
          .getFoo());
  expect([
    proto.jspb.test.ForeignEnum.FOREIGN_FOO
  ]).toEqual(msg.getExtension(proto.jspb.test.extendRepeatedForeignEnumList));


  expect(msg.getExtension(proto.jspb.test.extendPackedRepeatedInt32List))
      .toEqual([-42]);
  expect(msg.getExtension(proto.jspb.test.extendPackedRepeatedInt64List))
      .toEqual([-0x7fffffff00000000]);
  expect(msg.getExtension(proto.jspb.test.extendPackedRepeatedUint32List))
      .toEqual([0x80000000]);
  expect(msg.getExtension(proto.jspb.test.extendPackedRepeatedUint64List))
      .toEqual([0xf000000000000000]);
  expect(msg.getExtension(proto.jspb.test.extendPackedRepeatedSint32List))
      .toEqual([-100]);
  expect(msg.getExtension(proto.jspb.test.extendPackedRepeatedSint64List))
      .toEqual([-0x8000000000000000]);
  expect(msg.getExtension(proto.jspb.test.extendPackedRepeatedFixed32List))
      .toEqual([1234]);
  expect(msg.getExtension(proto.jspb.test.extendPackedRepeatedFixed64List))
      .toEqual([0x1234567800000000]);
  expect(msg.getExtension(proto.jspb.test.extendPackedRepeatedSfixed32List))
      .toEqual([-1234]);
  expect(msg.getExtension(proto.jspb.test.extendPackedRepeatedSfixed64List))
      .toEqual([-0x1234567800000000]);
  expect(msg.getExtension(proto.jspb.test.extendPackedRepeatedFloatList))
      .toEqual([1.5]);
  expect(msg.getExtension(proto.jspb.test.extendPackedRepeatedDoubleList))
      .toEqual([-1.5]);
  expect(msg.getExtension(proto.jspb.test.extendPackedRepeatedBoolList))
      .toEqual([true]);
  expect([proto.jspb.test.ForeignEnum.FOREIGN_FOO])
      .toEqual(msg.getExtension(
          proto.jspb.test.extendPackedRepeatedForeignEnumList));
}


describe('protoBinaryTest', () => {
  /**
   * Tests a basic serialization-deserializaton round-trip with all supported
   * field types (on the TestAllTypes message type).
   */
  it('testRoundTrip', () => {
    const msg = new proto.jspb.test.TestAllTypes();
    fillAllFields(msg);
    const encoded = msg.serializeBinary();
    const decoded = proto.jspb.test.TestAllTypes.deserializeBinary(encoded);
    checkAllFields(msg, decoded);
  });

  /**
   * Test that base64 string and Uint8Array are interchangeable in bytes fields.
   */
  it('testBytesFieldsGettersInterop', () => {
    let msg = new proto.jspb.test.TestAllTypes();
    // Set from a base64 string and check all the getters work.
    msg.setOptionalBytes(BYTES_B64);
    expect(bytesCompare(msg.getOptionalBytes_asU8(), BYTES)).toBeTrue();
    expect(bytesCompare(msg.getOptionalBytes_asB64(), BYTES)).toBeTrue();
    expect(bytesCompare(msg.getOptionalBytes(), BYTES)).toBeTrue();

    // Test binary serialize round trip doesn't break it.
    msg = proto.jspb.test.TestAllTypes.deserializeBinary(msg.serializeBinary());
    expect(bytesCompare(msg.getOptionalBytes_asU8(), BYTES)).toBeTrue();
    expect(bytesCompare(msg.getOptionalBytes_asB64(), BYTES)).toBeTrue();
    expect(bytesCompare(msg.getOptionalBytes(), BYTES)).toBeTrue();

    msg = new proto.jspb.test.TestAllTypes();
    // Set from a Uint8Array and check all the getters work.
    msg.setOptionalBytes(BYTES);
    expect(bytesCompare(msg.getOptionalBytes_asU8(), BYTES)).toBeTrue();
    expect(bytesCompare(msg.getOptionalBytes_asB64(), BYTES)).toBeTrue();
    expect(bytesCompare(msg.getOptionalBytes(), BYTES)).toBeTrue();
  });

  /**
   * Test that bytes setters will receive result of any of the getters.
   */
  it('testBytesFieldsSettersInterop', () => {
    const msg = new proto.jspb.test.TestAllTypes();
    msg.setOptionalBytes(BYTES);
    expect(bytesCompare(msg.getOptionalBytes(), BYTES)).toBeTrue();

    msg.setOptionalBytes(msg.getOptionalBytes());
    expect(bytesCompare(msg.getOptionalBytes(), BYTES)).toBeTrue();
    msg.setOptionalBytes(msg.getOptionalBytes_asB64());
    expect(bytesCompare(msg.getOptionalBytes(), BYTES)).toBeTrue();
    msg.setOptionalBytes(msg.getOptionalBytes_asU8());
    expect(bytesCompare(msg.getOptionalBytes(), BYTES)).toBeTrue();
  });

  /**
   * Test that bytes setters will receive result of any of the getters.
   */
  it('testRepeatedBytesGetters', () => {
    const msg = new proto.jspb.test.TestAllTypes();

    function assertGetters() {
      expect(typeof msg.getRepeatedBytesList_asB64()[0]).toEqual('string');
      expect(typeof msg.getRepeatedBytesList_asB64()[1]).toEqual('string');
      expect(msg.getRepeatedBytesList_asU8()[0] instanceof Uint8Array)
          .toBeTrue();
      expect(msg.getRepeatedBytesList_asU8()[1] instanceof Uint8Array)
          .toBeTrue();

      expect(bytesCompare(msg.getRepeatedBytesList()[0], BYTES)).toBeTrue();
      expect(bytesCompare(msg.getRepeatedBytesList()[1], BYTES)).toBeTrue();
      expect(bytesCompare(msg.getRepeatedBytesList_asB64()[0], BYTES))
          .toBeTrue();
      expect(bytesCompare(msg.getRepeatedBytesList_asB64()[1], BYTES))
          .toBeTrue();
      expect(bytesCompare(msg.getRepeatedBytesList_asU8()[0], BYTES))
          .toBeTrue();
      expect(bytesCompare(msg.getRepeatedBytesList_asU8()[1], BYTES))
          .toBeTrue();
    }
    msg.setRepeatedBytesList([BYTES, BYTES]);
    assertGetters();

    msg.setRepeatedBytesList([BYTES_B64, BYTES_B64]);
    assertGetters();

    msg.setRepeatedBytesList([]);
    expect(msg.getRepeatedBytesList().length).toEqual(0);
    expect(0).toEqual(msg.getRepeatedBytesList_asB64().length);
    expect(0).toEqual(msg.getRepeatedBytesList_asU8().length);
  });

  /**
   * Helper: fill all extension values.
   * @param {proto.jspb.test.TestExtendable} msg
   */
  function fillExtensions(msg) {
    msg.setExtension(proto.jspb.test.extendOptionalInt32, 0);
    msg.setExtension(proto.jspb.test.extendOptionalInt64, -0x7fffffff00000000);
    msg.setExtension(proto.jspb.test.extendOptionalUint32, 0x80000000);
    msg.setExtension(proto.jspb.test.extendOptionalUint64, 0xf000000000000000);
    msg.setExtension(proto.jspb.test.extendOptionalSint32, -100);
    msg.setExtension(proto.jspb.test.extendOptionalSint64, -0x8000000000000000);
    msg.setExtension(proto.jspb.test.extendOptionalFixed32, 1234);
    msg.setExtension(proto.jspb.test.extendOptionalFixed64, 0x1234567800000000);
    msg.setExtension(proto.jspb.test.extendOptionalSfixed32, -1234);
    msg.setExtension(
        proto.jspb.test.extendOptionalSfixed64, -0x1234567800000000);
    msg.setExtension(proto.jspb.test.extendOptionalFloat, 1.5);
    msg.setExtension(proto.jspb.test.extendOptionalDouble, -1.5);
    msg.setExtension(proto.jspb.test.extendOptionalBool, true);
    msg.setExtension(proto.jspb.test.extendOptionalString, 'hello world');
    msg.setExtension(proto.jspb.test.extendOptionalBytes, BYTES);
    let submsg = new proto.jspb.test.ExtendsWithMessage();
    submsg.setFoo(16);
    msg.setExtension(
        proto.jspb.test.ExtendsWithMessage.optionalExtension, submsg);
    msg.setExtension(
        proto.jspb.test.extendOptionalForeignEnum,
        proto.jspb.test.ForeignEnum.FOREIGN_FOO);


    msg.setExtension(proto.jspb.test.extendRepeatedInt32List, [-42]);
    msg.setExtension(
        proto.jspb.test.extendRepeatedInt64List, [-0x7fffffff00000000]);
    msg.setExtension(proto.jspb.test.extendRepeatedUint32List, [0x80000000]);
    msg.setExtension(
        proto.jspb.test.extendRepeatedUint64List, [0xf000000000000000]);
    msg.setExtension(proto.jspb.test.extendRepeatedSint32List, [-100]);
    msg.setExtension(
        proto.jspb.test.extendRepeatedSint64List, [-0x8000000000000000]);
    msg.setExtension(proto.jspb.test.extendRepeatedFixed32List, [1234]);
    msg.setExtension(
        proto.jspb.test.extendRepeatedFixed64List, [0x1234567800000000]);
    msg.setExtension(proto.jspb.test.extendRepeatedSfixed32List, [-1234]);
    msg.setExtension(
        proto.jspb.test.extendRepeatedSfixed64List, [-0x1234567800000000]);
    msg.setExtension(proto.jspb.test.extendRepeatedFloatList, [1.5]);
    msg.setExtension(proto.jspb.test.extendRepeatedDoubleList, [-1.5]);
    msg.setExtension(proto.jspb.test.extendRepeatedBoolList, [true]);
    msg.setExtension(proto.jspb.test.extendRepeatedStringList, ['hello world']);
    msg.setExtension(proto.jspb.test.extendRepeatedBytesList, [BYTES]);
    submsg = new proto.jspb.test.ExtendsWithMessage();
    submsg.setFoo(1000);
    msg.setExtension(
        proto.jspb.test.ExtendsWithMessage.repeatedExtensionList, [submsg]);
    msg.setExtension(
        proto.jspb.test.extendRepeatedForeignEnumList,
        [proto.jspb.test.ForeignEnum.FOREIGN_FOO]);


    msg.setExtension(proto.jspb.test.extendPackedRepeatedInt32List, [-42]);
    msg.setExtension(
        proto.jspb.test.extendPackedRepeatedInt64List, [-0x7fffffff00000000]);
    msg.setExtension(
        proto.jspb.test.extendPackedRepeatedUint32List, [0x80000000]);
    msg.setExtension(
        proto.jspb.test.extendPackedRepeatedUint64List, [0xf000000000000000]);
    msg.setExtension(proto.jspb.test.extendPackedRepeatedSint32List, [-100]);
    msg.setExtension(
        proto.jspb.test.extendPackedRepeatedSint64List, [-0x8000000000000000]);
    msg.setExtension(proto.jspb.test.extendPackedRepeatedFixed32List, [1234]);
    msg.setExtension(
        proto.jspb.test.extendPackedRepeatedFixed64List, [0x1234567800000000]);
    msg.setExtension(proto.jspb.test.extendPackedRepeatedSfixed32List, [-1234]);
    msg.setExtension(
        proto.jspb.test.extendPackedRepeatedSfixed64List,
        [-0x1234567800000000]);
    msg.setExtension(proto.jspb.test.extendPackedRepeatedFloatList, [1.5]);
    msg.setExtension(proto.jspb.test.extendPackedRepeatedDoubleList, [-1.5]);
    msg.setExtension(proto.jspb.test.extendPackedRepeatedBoolList, [true]);
    msg.setExtension(
        proto.jspb.test.extendPackedRepeatedForeignEnumList,
        [proto.jspb.test.ForeignEnum.FOREIGN_FOO]);
  }


  /**
   * Tests extension serialization and deserialization.
   */
  it('testExtensions', () => {
    const msg = new proto.jspb.test.TestExtendable();
    fillExtensions(msg);
    const encoded = msg.serializeBinary();
    const decoded = proto.jspb.test.TestExtendable.deserializeBinary(encoded);
    checkExtensions(decoded);
  });

  /**
   * Tests that unknown extensions don't cause deserialization failure.
   */
  it('testUnknownExtension', () => {
    const msg = new proto.jspb.test.TestExtendable();
    fillExtensions(msg);
    const writer = new jspb.BinaryWriter();
    writer.writeBool((1 << 29) - 1, true);
    proto.jspb.test.TestExtendable.serializeBinaryToWriter(msg, writer);
    const encoded = writer.getResultBuffer();
    const decoded = proto.jspb.test.TestExtendable.deserializeBinary(encoded);
    checkExtensions(decoded);
  });

  it('testAnyWellKnownType', () => {
    const any = new proto.google.protobuf.Any();
    const msg = new proto.jspb.test.TestAllTypes();

    fillAllFields(msg);

    any.pack(msg.serializeBinary(), 'jspb.test.TestAllTypes');

    expect(any.getTypeUrl())
        .toEqual('type.googleapis.com/jspb.test.TestAllTypes');

    const msg2 = any.unpack(
        proto.jspb.test.TestAllTypes.deserializeBinary,
        'jspb.test.TestAllTypes');

    checkAllFields(msg, msg2);
  });
});