/**
 * @fileoverview Tests for writer.js.
 */
goog.module('protobuf.binary.WriterTest');

goog.setTestOnly();

// Note to the reader:
// Since the writer behavior changes with the checking level some of the tests
// in this file have to know which checking level is enable to make correct
// assertions.
const BufferDecoder = goog.require('protobuf.binary.BufferDecoder');
const ByteString = goog.require('protobuf.ByteString');
const WireType = goog.require('protobuf.binary.WireType');
const Writer = goog.require('protobuf.binary.Writer');
const {CHECK_BOUNDS, CHECK_TYPE, MAX_FIELD_NUMBER} = goog.require('protobuf.internal.checks');
const {arrayBufferSlice} = goog.require('protobuf.binary.typedArrays');
const {getDoublePairs} = goog.require('protobuf.binary.doubleTestPairs');
const {getFixed32Pairs} = goog.require('protobuf.binary.fixed32TestPairs');
const {getFloatPairs} = goog.require('protobuf.binary.floatTestPairs');
const {getInt32Pairs} = goog.require('protobuf.binary.int32TestPairs');
const {getInt64Pairs} = goog.require('protobuf.binary.int64TestPairs');
const {getPackedBoolPairs} = goog.require('protobuf.binary.packedBoolTestPairs');
const {getPackedDoublePairs} = goog.require('protobuf.binary.packedDoubleTestPairs');
const {getPackedFixed32Pairs} = goog.require('protobuf.binary.packedFixed32TestPairs');
const {getPackedFloatPairs} = goog.require('protobuf.binary.packedFloatTestPairs');
const {getPackedInt32Pairs} = goog.require('protobuf.binary.packedInt32TestPairs');
const {getPackedInt64Pairs} = goog.require('protobuf.binary.packedInt64TestPairs');
const {getPackedSfixed32Pairs} = goog.require('protobuf.binary.packedSfixed32TestPairs');
const {getPackedSfixed64Pairs} = goog.require('protobuf.binary.packedSfixed64TestPairs');
const {getPackedSint32Pairs} = goog.require('protobuf.binary.packedSint32TestPairs');
const {getPackedSint64Pairs} = goog.require('protobuf.binary.packedSint64TestPairs');
const {getPackedUint32Pairs} = goog.require('protobuf.binary.packedUint32TestPairs');
const {getSfixed32Pairs} = goog.require('protobuf.binary.sfixed32TestPairs');
const {getSfixed64Pairs} = goog.require('protobuf.binary.sfixed64TestPairs');
const {getSint32Pairs} = goog.require('protobuf.binary.sint32TestPairs');
const {getSint64Pairs} = goog.require('protobuf.binary.sint64TestPairs');
const {getUint32Pairs} = goog.require('protobuf.binary.uint32TestPairs');


/**
 * @param {...number} bytes
 * @return {!ArrayBuffer}
 */
function createArrayBuffer(...bytes) {
  return new Uint8Array(bytes).buffer;
}

/******************************************************************************
 *                        OPTIONAL FUNCTIONS
 ******************************************************************************/

describe('Writer does', () => {
  it('return an empty ArrayBuffer when nothing is encoded', () => {
    const writer = new Writer();
    expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
  });

  it('encode tag', () => {
    const writer = new Writer();
    writer.writeTag(1, WireType.VARINT);
    expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer(0x08));

    writer.writeTag(0x0FFFFFFF, WireType.VARINT);
    expect(writer.getAndResetResultBuffer())
        .toEqual(createArrayBuffer(0xF8, 0xFF, 0xFF, 0xFF, 0x7));

    writer.writeTag(0x10000000, WireType.VARINT);
    expect(writer.getAndResetResultBuffer())
        .toEqual(createArrayBuffer(0x80, 0x80, 0x80, 0x80, 0x08));

    writer.writeTag(0x1FFFFFFF, WireType.VARINT);
    expect(writer.getAndResetResultBuffer())
        .toEqual(createArrayBuffer(0xF8, 0xFF, 0xFF, 0xFF, 0x0F));
  });

  it('reset after calling getAndResetResultBuffer', () => {
    const writer = new Writer();
    writer.writeTag(1, WireType.VARINT);
    writer.getAndResetResultBuffer();
    expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
  });

  it('fail when field number is too large for writeTag', () => {
    const writer = new Writer();
    if (CHECK_TYPE) {
      expect(() => writer.writeTag(MAX_FIELD_NUMBER + 1, WireType.VARINT))
          .toThrowError('Field number is out of range: 536870912');
    } else {
      // Note in unchecked mode we produce invalid output for invalid inputs.
      // This test just documents our behavior in those cases.
      // These values might change at any point and are not considered
      // what the implementation should be doing here.
      writer.writeTag(MAX_FIELD_NUMBER + 1, WireType.VARINT);
      expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer(0));
    }
  });

  it('fail when field number is negative for writeTag', () => {
    const writer = new Writer();
    if (CHECK_TYPE) {
      expect(() => writer.writeTag(-1, WireType.VARINT))
          .toThrowError('Field number is out of range: -1');
    } else {
      // Note in unchecked mode we produce invalid output for invalid inputs.
      // This test just documents our behavior in those cases.
      // These values might change at any point and are not considered
      // what the implementation should be doing here.
      writer.writeTag(-1, WireType.VARINT);
      expect(writer.getAndResetResultBuffer())
          .toEqual(createArrayBuffer(0xF8, 0xFF, 0xFF, 0xFF, 0xF));
    }
  });

  it('fail when wire type is invalid for writeTag', () => {
    const writer = new Writer();
    if (CHECK_TYPE) {
      expect(() => writer.writeTag(1, /** @type {!WireType} */ (0x08)))
          .toThrowError('Invalid wire type: 8');
    } else {
      // Note in unchecked mode we produce invalid output for invalid inputs.
      // This test just documents our behavior in those cases.
      // These values might change at any point and are not considered
      // what the implementation should be doing here.
      writer.writeTag(1, /** @type {!WireType} */ (0x08));
      expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer(0x08));
    }
  });

  it('encode singular boolean value', () => {
    const writer = new Writer();
    writer.writeBool(1, true);
    expect(writer.getAndResetResultBuffer())
        .toEqual(createArrayBuffer(0x08, 0x01));
  });

  it('encode length delimited', () => {
    const writer = new Writer();
    writer.writeDelimited(1, createArrayBuffer(0x01, 0x02));
    expect(writer.getAndResetResultBuffer())
        .toEqual(createArrayBuffer(0x0A, 0x02, 0x01, 0x02));
  });
});

describe('Writer.writeBufferDecoder does', () => {
  it('encode BufferDecoder containing a varint value', () => {
    const writer = new Writer();
    const expected = createArrayBuffer(
        0x08, /* varint start= */ 0xFF, /* varint end= */ 0x01, 0x08, 0x01);
    writer.writeBufferDecoder(
        BufferDecoder.fromArrayBuffer(expected), 1, WireType.VARINT, 1);
    const result = writer.getAndResetResultBuffer();
    expect(result).toEqual(arrayBufferSlice(expected, 1, 3));
  });

  it('encode BufferDecoder containing a fixed64 value', () => {
    const writer = new Writer();
    const expected = createArrayBuffer(
        0x09, /* fixed64 start= */ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
        /* fixed64 end= */ 0x08, 0x08, 0x01);
    writer.writeBufferDecoder(
        BufferDecoder.fromArrayBuffer(expected), 1, WireType.FIXED64, 1);
    const result = writer.getAndResetResultBuffer();
    expect(result).toEqual(arrayBufferSlice(expected, 1, 9));
  });

  it('encode BufferDecoder containing a length delimited value', () => {
    const writer = new Writer();
    const expected = createArrayBuffer(
        0xA, /* length= */ 0x03, /* data start= */ 0x01, 0x02,
        /* data end= */ 0x03, 0x08, 0x01);
    writer.writeBufferDecoder(
        BufferDecoder.fromArrayBuffer(expected), 1, WireType.DELIMITED, 1);
    const result = writer.getAndResetResultBuffer();
    expect(result).toEqual(arrayBufferSlice(expected, 1, 5));
  });

  it('encode BufferDecoder containing a group', () => {
    const writer = new Writer();
    const expected = createArrayBuffer(
        0xB, /* group start= */ 0x08, 0x01, /* nested group start= */ 0x0B,
        /* nested group end= */ 0x0C, /* group end= */ 0x0C, 0x08, 0x01);
    writer.writeBufferDecoder(
        BufferDecoder.fromArrayBuffer(expected), 1, WireType.START_GROUP, 1);
    const result = writer.getAndResetResultBuffer();
    expect(result).toEqual(arrayBufferSlice(expected, 1, 6));
  });

  it('encode BufferDecoder containing a fixed32 value', () => {
    const writer = new Writer();
    const expected = createArrayBuffer(
        0x09, /* fixed64 start= */ 0x01, 0x02, 0x03, /* fixed64 end= */ 0x04,
        0x08, 0x01);
    writer.writeBufferDecoder(
        BufferDecoder.fromArrayBuffer(expected), 1, WireType.FIXED32, 1);
    const result = writer.getAndResetResultBuffer();
    expect(result).toEqual(arrayBufferSlice(expected, 1, 5));
  });

  it('fail when encoding out of bound data', () => {
    const writer = new Writer();
    const buffer = createArrayBuffer(0x4, 0x0, 0x1, 0x2, 0x3);
    const subBuffer = arrayBufferSlice(buffer, 0, 2);
    expect(
        () => writer.writeBufferDecoder(
            BufferDecoder.fromArrayBuffer(subBuffer), 0, WireType.DELIMITED, 1))
        .toThrow();
  });
});

describe('Writer.writeBytes does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  it('encodes empty ByteString', () => {
    writer.writeBytes(1, ByteString.EMPTY);
    const buffer = writer.getAndResetResultBuffer();
    expect(buffer.byteLength).toBe(2);
  });

  it('encodes empty array', () => {
    writer.writeBytes(1, ByteString.fromArrayBuffer(new ArrayBuffer(0)));
    expect(writer.getAndResetResultBuffer())
        .toEqual(createArrayBuffer(
            1 << 3 | 0x02,  // tag (fieldnumber << 3 | (length delimited))
            0,              // length of the bytes
            ));
  });

  it('encodes ByteString', () => {
    const array = createArrayBuffer(1, 2, 3);
    writer.writeBytes(1, ByteString.fromArrayBuffer(array));
    expect(writer.getAndResetResultBuffer())
        .toEqual(createArrayBuffer(
            1 << 3 | 0x02,  // tag (fieldnumber << 3 | (length delimited))
            3,              // length of the bytes
            1,
            2,
            3,
            ));
  });
});

describe('Writer.writeDouble does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  for (const pair of getDoublePairs()) {
    it(`encode ${pair.name}`, () => {
        writer.writeDouble(1, pair.doubleValue);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        expect(buffer.length).toBe(9);
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x09);
        // Encoded values are stored right after the tag
        expect(buffer.subarray(1, 9))
            .toEqual(pair.bufferDecoder.asUint8Array());
    });
  }

  /**
   * NaN may have different value in different browsers. Thus, we need to make
   * the test lenient.
   */
  it('encode NaN', () => {
    writer.writeDouble(1, NaN);
    const buffer = new Uint8Array(writer.getAndResetResultBuffer());
    expect(buffer.length).toBe(9);
    // ensure we have a correct tag
    expect(buffer[0]).toEqual(0x09);
    // Encoded values are stored right after the tag
    const float64 = new DataView(buffer.buffer);
    expect(float64.getFloat64(1, true)).toBeNaN();
  });
});

describe('Writer.writeFixed32 does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  for (const pair of getFixed32Pairs()) {
    it(`encode ${pair.name}`, () => {
      writer.writeFixed32(1, pair.intValue);
      const buffer = new Uint8Array(writer.getAndResetResultBuffer());
      expect(buffer.length).toBe(5);
      // ensure we have a correct tag
      expect(buffer[0]).toEqual(0x0D);
      // Encoded values are stored right after the tag
      expect(buffer.subarray(1, 5)).toEqual(pair.bufferDecoder.asUint8Array());
    });
  }
});

describe('Writer.writeFloat does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  for (const pair of getFloatPairs()) {
    it(`encode ${pair.name}`, () => {
      writer.writeFloat(1, pair.floatValue);
      const buffer = new Uint8Array(writer.getAndResetResultBuffer());
      expect(buffer.length).toBe(5);
      // ensure we have a correct tag
      expect(buffer[0]).toEqual(0x0D);
      // Encoded values are stored right after the tag
      expect(buffer.subarray(1, 5)).toEqual(pair.bufferDecoder.asUint8Array());
    });
  }

  /**
   * NaN may have different value in different browsers. Thus, we need to make
   * the test lenient.
   */
  it('encode NaN', () => {
    writer.writeFloat(1, NaN);
    const buffer = new Uint8Array(writer.getAndResetResultBuffer());
    expect(buffer.length).toBe(5);
    // ensure we have a correct tag
    expect(buffer[0]).toEqual(0x0D);
    // Encoded values are stored right after the tag
    const float32 = new DataView(buffer.buffer);
    expect(float32.getFloat32(1, true)).toBeNaN();
  });
});

describe('Writer.writeInt32 does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  for (const pair of getInt32Pairs()) {
    if (!pair.skip_writer) {
      it(`encode ${pair.name}`, () => {
        writer.writeInt32(1, pair.intValue);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x08);
        // Encoded values are stored right after the tag
        expect(buffer.subarray(1, buffer.length))
            .toEqual(pair.bufferDecoder.asUint8Array());
      });
    }
  }
});

describe('Writer.writeSfixed32 does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  it('encode empty array', () => {
    writer.writePackedSfixed32(1, []);
    expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
  });

  for (const pair of getSfixed32Pairs()) {
    it(`encode ${pair.name}`, () => {
      writer.writeSfixed32(1, pair.intValue);
      const buffer = new Uint8Array(writer.getAndResetResultBuffer());
      expect(buffer.length).toBe(5);
      // ensure we have a correct tag
      expect(buffer[0]).toEqual(0x0D);
      // Encoded values are stored right after the tag
      expect(buffer.subarray(1, 5)).toEqual(pair.bufferDecoder.asUint8Array());
    });
  }
});

describe('Writer.writeSfixed64 does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  for (const pair of getSfixed64Pairs()) {
    it(`encode ${pair.name}`, () => {
      writer.writeSfixed64(1, pair.longValue);
      const buffer = new Uint8Array(writer.getAndResetResultBuffer());
      expect(buffer.length).toBe(9);
      // ensure we have a correct tag
      expect(buffer[0]).toEqual(0x09);
      // Encoded values are stored right after the tag
      expect(buffer.subarray(1, 9)).toEqual(pair.bufferDecoder.asUint8Array());
    });
  }
});

describe('Writer.writeSint32 does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  for (const pair of getSint32Pairs()) {
    if (!pair.skip_writer) {
      it(`encode ${pair.name}`, () => {
        writer.writeSint32(1, pair.intValue);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x08);
        // Encoded values are stored right after the tag
        expect(buffer.subarray(1, buffer.length))
            .toEqual(pair.bufferDecoder.asUint8Array());
      });
    }
  }
});

describe('Writer.writeSint64 does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  for (const pair of getSint64Pairs()) {
    if (!pair.skip_writer) {
      it(`encode ${pair.name}`, () => {
        writer.writeSint64(1, pair.longValue);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x08);
        // Encoded values are stored right after the tag
        expect(buffer.subarray(1, buffer.length))
            .toEqual(pair.bufferDecoder.asUint8Array());
      });
    }
  }
});

describe('Writer.writeInt64 does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  for (const pair of getInt64Pairs()) {
    if (!pair.skip_writer) {
      it(`encode ${pair.name}`, () => {
        writer.writeInt64(1, pair.longValue);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x08);
        // Encoded values are stored right after the tag
        expect(buffer.subarray(1, buffer.length))
            .toEqual(pair.bufferDecoder.asUint8Array());
      });
    }
  }
});

describe('Writer.writeUint32 does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  for (const pair of getUint32Pairs()) {
    if (!pair.skip_writer) {
      it(`encode ${pair.name}`, () => {
        writer.writeUint32(1, pair.intValue);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x08);
        // Encoded values are stored right after the tag
        expect(buffer.subarray(1, buffer.length))
            .toEqual(pair.bufferDecoder.asUint8Array());
      });
    }
  }
});

describe('Writer.writeString does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  it('encode empty string', () => {
    writer.writeString(1, '');
    expect(writer.getAndResetResultBuffer())
        .toEqual(createArrayBuffer(
            1 << 3 | 0x02,  // tag (fieldnumber << 3 | (length delimited))
            0,              // length of the string
            ));
  });

  it('encode simple string', () => {
    writer.writeString(1, 'hello');
    expect(writer.getAndResetResultBuffer())
        .toEqual(createArrayBuffer(
            1 << 3 | 0x02,  // tag (fieldnumber << 3 | (length delimited))
            5,              // length of the string
            'h'.charCodeAt(0),
            'e'.charCodeAt(0),
            'l'.charCodeAt(0),
            'l'.charCodeAt(0),
            'o'.charCodeAt(0),
            ));
  });

  it('throw for invalid fieldnumber', () => {
    if (CHECK_BOUNDS) {
      expect(() => writer.writeString(-1, 'a'))
          .toThrowError('Field number is out of range: -1');
    } else {
      writer.writeString(-1, 'a');
      expect(new Uint8Array(writer.getAndResetResultBuffer()))
          .toEqual(new Uint8Array(createArrayBuffer(
              -6,  // invalid tag
              0xff,
              0xff,
              0xff,
              0x0f,
              1,  // string length
              'a'.charCodeAt(0),
              )));
    }
  });

  it('throw for null string value', () => {
    expect(
        () => writer.writeString(
            1, /** @type {string} */ (/** @type {*} */ (null))))
        .toThrow();
  });
});


/******************************************************************************
 *                        REPEATED FUNCTIONS
 ******************************************************************************/

describe('Writer.writePackedBool does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  it('encode empty array', () => {
    writer.writePackedBool(1, []);
    expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
  });

  for (const pair of getPackedBoolPairs()) {
    if (!pair.skip_writer) {
      it(`encode ${pair.name}`, () => {
        writer.writePackedBool(1, pair.boolValues);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x0A);
        // Encoded values are stored right after the tag
        expect(buffer.subarray(1, buffer.length))
            .toEqual(pair.bufferDecoder.asUint8Array());
      });
    }
  }
});

describe('Writer.writeRepeatedBool does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  it('encode empty array', () => {
    writer.writeRepeatedBool(1, []);
    expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
  });

  it('encode repeated unpacked boolean values', () => {
    const writer = new Writer();
    writer.writeRepeatedBool(1, [true, false]);
    expect(writer.getAndResetResultBuffer())
        .toEqual(createArrayBuffer(
            1 << 3 | 0x00,  // tag (fieldnumber << 3 | (varint))
            0x01,           // value[0]
            1 << 3 | 0x00,  // tag (fieldnumber << 3 | (varint))
            0x00,           // value[1]
            ));
  });
});

describe('Writer.writePackedDouble does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  it('encode empty array', () => {
    writer.writePackedDouble(1, []);
    expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
  });

  for (const pair of getPackedDoublePairs()) {
    if (!pair.skip_writer) {
      it(`encode ${pair.name}`, () => {
        writer.writePackedDouble(1, pair.doubleValues);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x0A);
        // Encoded values are stored right after the tag
        expect(buffer.subarray(1, buffer.length))
            .toEqual(pair.bufferDecoder.asUint8Array());
      });
    }
  }
});

describe('Writer.writePackedFixed32 does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  it('encode empty array', () => {
    writer.writePackedFixed32(1, []);
    expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
  });

  for (const pair of getPackedFixed32Pairs()) {
    if (!pair.skip_writer) {
      it(`encode ${pair.name}`, () => {
        writer.writePackedFixed32(1, pair.fixed32Values);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x0A);
        // Encoded values are stored right after the tag
        expect(buffer.subarray(1, buffer.length))
            .toEqual(pair.bufferDecoder.asUint8Array());
      });
    }
  }
});

describe('Writer.writePackedFloat does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  it('encode empty array', () => {
    writer.writePackedFloat(1, []);
    expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
  });

  for (const pair of getPackedFloatPairs()) {
    if (!pair.skip_writer) {
      it(`encode ${pair.name}`, () => {
        writer.writePackedFloat(1, pair.floatValues);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x0A);
        // Encoded values are stored right after the tag
        expect(buffer.subarray(1, buffer.length))
            .toEqual(pair.bufferDecoder.asUint8Array());
      });
    }
  }
});

describe('Writer.writePackedInt32 does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  it('encode empty array', () => {
    writer.writePackedInt32(1, []);
    expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
  });

  for (const pair of getPackedInt32Pairs()) {
    if (!pair.skip_writer) {
      it(`encode ${pair.name}`, () => {
        writer.writePackedInt32(1, pair.int32Values);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x0A);
        // Encoded values are stored right after the tag
        expect(buffer.subarray(1, buffer.length))
            .toEqual(pair.bufferDecoder.asUint8Array());
      });
    }
  }
});

describe('Writer.writePackedInt64 does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  it('encode empty array', () => {
    writer.writePackedInt64(1, []);
    expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
  });

  for (const pair of getPackedInt64Pairs()) {
    if (!pair.skip_writer) {
      it(`encode ${pair.name}`, () => {
        writer.writePackedInt64(1, pair.int64Values);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x0A);
        // Encoded values are stored right after the tag
        expect(buffer.subarray(1, buffer.length))
            .toEqual(pair.bufferDecoder.asUint8Array());
      });
    }
  }
});

describe('Writer.writePackedSfixed32 does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  it('encode empty array', () => {
    writer.writePackedSfixed32(1, []);
    expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
  });

  for (const pair of getPackedSfixed32Pairs()) {
    if (!pair.skip_writer) {
      it(`encode ${pair.name}`, () => {
        writer.writePackedSfixed32(1, pair.sfixed32Values);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x0A);
        // Encoded values are stored right after the tag
        expect(buffer.subarray(1, buffer.length))
            .toEqual(pair.bufferDecoder.asUint8Array());
      });
    }
  }
});

describe('Writer.writePackedSfixed64 does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  it('encode empty array', () => {
    writer.writePackedSfixed64(1, []);
    expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
  });

  for (const pair of getPackedSfixed64Pairs()) {
    if (!pair.skip_writer) {
      it(`encode ${pair.name}`, () => {
        writer.writePackedSfixed64(1, pair.sfixed64Values);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x0A);
        // Encoded values are stored right after the tag
        expect(buffer.subarray(1, buffer.length))
            .toEqual(pair.bufferDecoder.asUint8Array());
      });
    }
  }
});

describe('Writer.writePackedSint32 does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  it('encode empty array', () => {
    writer.writePackedSint32(1, []);
    expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
  });

  for (const pair of getPackedSint32Pairs()) {
    if (!pair.skip_writer) {
      it(`encode ${pair.name}`, () => {
        writer.writePackedSint32(1, pair.sint32Values);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x0A);
        // Encoded values are stored right after the tag
        expect(buffer.subarray(1, buffer.length))
            .toEqual(pair.bufferDecoder.asUint8Array());
      });
    }
  }
});

describe('Writer.writePackedSint64 does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  it('encode empty array', () => {
    writer.writePackedSint64(1, []);
    expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
  });

  for (const pair of getPackedSint64Pairs()) {
    if (!pair.skip_writer) {
      it(`encode ${pair.name}`, () => {
        writer.writePackedSint64(1, pair.sint64Values);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x0A);
        // Encoded values are stored right after the tag
        expect(buffer.subarray(1, buffer.length))
            .toEqual(pair.bufferDecoder.asUint8Array());
      });
    }
  }
});

describe('Writer.writePackedUint32 does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  it('encode empty array', () => {
    writer.writePackedUint32(1, []);
    expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
  });

  for (const pair of getPackedUint32Pairs()) {
    if (!pair.skip_writer) {
      it(`encode ${pair.name}`, () => {
        writer.writePackedUint32(1, pair.uint32Values);
        const buffer = new Uint8Array(writer.getAndResetResultBuffer());
        // ensure we have a correct tag
        expect(buffer[0]).toEqual(0x0A);
        // Encoded values are stored right after the tag
        expect(buffer.subarray(1, buffer.length))
            .toEqual(pair.bufferDecoder.asUint8Array());
      });
    }
  }
});

describe('Writer.writeRepeatedBytes does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  it('encode empty array', () => {
    writer.writeRepeatedBytes(1, []);
    expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
  });

  it('encode single value', () => {
    const value = createArrayBuffer(0x61);
    writer.writeRepeatedBytes(1, [ByteString.fromArrayBuffer(value)]);
    expect(writer.getAndResetResultBuffer())
        .toEqual(createArrayBuffer(
            0x0A,
            0x01,
            0x61,  // a
            ));
  });

  it('encode multiple values', () => {
    const value1 = createArrayBuffer(0x61);
    const value2 = createArrayBuffer(0x62);
    writer.writeRepeatedBytes(1, [
      ByteString.fromArrayBuffer(value1),
      ByteString.fromArrayBuffer(value2),
    ]);
    expect(writer.getAndResetResultBuffer())
        .toEqual(createArrayBuffer(
            0x0A,
            0x01,
            0x61,  // a
            0x0A,
            0x01,
            0x62,  // b
            ));
  });
});

describe('Writer.writeRepeatedString does', () => {
  let writer;
  beforeEach(() => {
    writer = new Writer();
  });

  it('encode empty array', () => {
    writer.writeRepeatedString(1, []);
    expect(writer.getAndResetResultBuffer()).toEqual(createArrayBuffer());
  });

  it('encode single value', () => {
    writer.writeRepeatedString(1, ['a']);
    expect(writer.getAndResetResultBuffer())
        .toEqual(createArrayBuffer(
            0x0A,
            0x01,
            0x61,  // a
            ));
  });

  it('encode multiple values', () => {
    writer.writeRepeatedString(1, ['a', 'b']);
    expect(writer.getAndResetResultBuffer())
        .toEqual(createArrayBuffer(
            0x0A,
            0x01,
            0x61,  // a
            0x0A,
            0x01,
            0x62,  // b
            ));
  });
});