Add dependencies locally

deps/protobuf/js/experimental/runtime/kernel/conformance/conformance_request.js

@@ -0,0 +1,91 @@
+/**
+ * @fileoverview Handwritten code of ConformanceRequest.
+ */
+goog.module('proto.conformance.ConformanceRequest');
+
+const Kernel = goog.require('protobuf.runtime.Kernel');
+const WireFormat = goog.require('proto.conformance.WireFormat');
+
+/**
+ * Handwritten code of conformance.ConformanceRequest.
+ * This is used to send request from the conformance test runner to the testee.
+ * Check //third_party/protobuf/testing/protobuf/conformance/conformance.proto
+ * for more details.
+ * @final
+ */
+class ConformanceRequest {
+  /**
+   * @param {!ArrayBuffer} bytes
+   * @private
+   */
+  constructor(bytes) {
+    /** @private @const {!Kernel} */
+    this.accessor_ = Kernel.fromArrayBuffer(bytes);
+  }
+
+  /**
+   * Create a request instance with the given bytes data.
+   * @param {!ArrayBuffer} bytes
+   * @return {!ConformanceRequest}
+   */
+  static deserialize(bytes) {
+    return new ConformanceRequest(bytes);
+  }
+
+  /**
+   * Gets the protobuf_payload.
+   * @return {!ArrayBuffer}
+   */
+  getProtobufPayload() {
+    return this.accessor_.getBytesWithDefault(1).toArrayBuffer();
+  }
+
+  /**
+   * Gets the requested_output_format.
+   * @return {!WireFormat}
+   */
+  getRequestedOutputFormat() {
+    return /** @type {!WireFormat} */ (this.accessor_.getInt32WithDefault(3));
+  }
+
+  /**
+   * Gets the message_type.
+   * @return {string}
+   */
+  getMessageType() {
+    return this.accessor_.getStringWithDefault(4);
+  }
+
+  /**
+   * Gets the oneof case for payload field.
+   * This implementation assumes only one field in a oneof group is set.
+   * @return {!ConformanceRequest.PayloadCase}
+   */
+  getPayloadCase() {
+    if (this.accessor_.hasFieldNumber(1)) {
+      return /** @type {!ConformanceRequest.PayloadCase} */ (
+          ConformanceRequest.PayloadCase.PROTOBUF_PAYLOAD);
+    } else if (this.accessor_.hasFieldNumber(2)) {
+      return /** @type {!ConformanceRequest.PayloadCase} */ (
+          ConformanceRequest.PayloadCase.JSON_PAYLOAD);
+    } else if (this.accessor_.hasFieldNumber(8)) {
+      return /** @type {!ConformanceRequest.PayloadCase} */ (
+          ConformanceRequest.PayloadCase.TEXT_PAYLOAD);
+    } else {
+      return /** @type {!ConformanceRequest.PayloadCase} */ (
+          ConformanceRequest.PayloadCase.PAYLOAD_NOT_SET);
+    }
+  }
+}
+
+/**
+ * @enum {number}
+ */
+ConformanceRequest.PayloadCase = {
+  PAYLOAD_NOT_SET: 0,
+  PROTOBUF_PAYLOAD: 1,
+  JSON_PAYLOAD: 2,
+  TEXT_PAYLOAD: 8,
+};
+
+exports = ConformanceRequest;

deps/protobuf/js/experimental/runtime/kernel/conformance/conformance_response.js

@@ -0,0 +1,76 @@
+/**
+ * @fileoverview Handwritten code of ConformanceResponse.
+ */
+goog.module('proto.conformance.ConformanceResponse');
+
+const ByteString = goog.require('protobuf.ByteString');
+const Kernel = goog.require('protobuf.runtime.Kernel');
+
+/**
+ * Handwritten code of conformance.ConformanceResponse.
+ * This is used to send response from the conformance testee to the test runner.
+ * Check //third_party/protobuf/testing/protobuf/conformance/conformance.proto
+ * for more details.
+ * @final
+ */
+class ConformanceResponse {
+  /**
+   * @param {!ArrayBuffer} bytes
+   * @private
+   */
+  constructor(bytes) {
+    /** @private @const {!Kernel} */
+    this.accessor_ = Kernel.fromArrayBuffer(bytes);
+  }
+
+  /**
+   * Create an empty response instance.
+   * @return {!ConformanceResponse}
+   */
+  static createEmpty() {
+    return new ConformanceResponse(new ArrayBuffer(0));
+  }
+
+  /**
+   * Sets parse_error field.
+   * @param {string} value
+   */
+  setParseError(value) {
+    this.accessor_.setString(1, value);
+  }
+
+  /**
+   * Sets runtime_error field.
+   * @param {string} value
+   */
+  setRuntimeError(value) {
+    this.accessor_.setString(2, value);
+  }
+
+  /**
+   * Sets protobuf_payload field.
+   * @param {!ArrayBuffer} value
+   */
+  setProtobufPayload(value) {
+    const bytesString = ByteString.fromArrayBuffer(value);
+    this.accessor_.setBytes(3, bytesString);
+  }
+
+  /**
+   * Sets skipped field.
+   * @param {string} value
+   */
+  setSkipped(value) {
+    this.accessor_.setString(5, value);
+  }
+
+  /**
+   * Serializes into binary data.
+   * @return {!ArrayBuffer}
+   */
+  serialize() {
+    return this.accessor_.serialize();
+  }
+}
+
+exports = ConformanceResponse;

deps/protobuf/js/experimental/runtime/kernel/conformance/conformance_testee.js

@@ -0,0 +1,103 @@
+goog.module('javascript.protobuf.conformance');
+
+const ConformanceRequest = goog.require('proto.conformance.ConformanceRequest');
+const ConformanceResponse = goog.require('proto.conformance.ConformanceResponse');
+const TestAllTypesProto2 = goog.require('proto.conformance.TestAllTypesProto2');
+const TestAllTypesProto3 = goog.require('proto.conformance.TestAllTypesProto3');
+const WireFormat = goog.require('proto.conformance.WireFormat');
+const base64 = goog.require('goog.crypt.base64');
+
+/**
+ * Creates a `proto.conformance.ConformanceResponse` response according to the
+ * `proto.conformance.ConformanceRequest` request.
+ * @param {!ConformanceRequest} request
+ * @return {!ConformanceResponse} response
+ */
+function doTest(request) {
+  const response = ConformanceResponse.createEmpty();
+
+  if(request.getPayloadCase() === ConformanceRequest.PayloadCase.JSON_PAYLOAD) {
+    response.setSkipped('Json is not supported as input format.');
+    return response;
+  }
+
+  if(request.getPayloadCase() === ConformanceRequest.PayloadCase.TEXT_PAYLOAD) {
+    response.setSkipped('Text format is not supported as input format.');
+    return response;
+  }
+
+  if(request.getPayloadCase() === ConformanceRequest.PayloadCase.PAYLOAD_NOT_SET) {
+    response.setRuntimeError('Request didn\'t have payload.');
+    return response;
+  }
+
+  if(request.getPayloadCase() !== ConformanceRequest.PayloadCase.PROTOBUF_PAYLOAD) {
+     throw new Error('Request didn\'t have accepted input format.');
+  }
+
+  if (request.getRequestedOutputFormat() === WireFormat.JSON) {
+    response.setSkipped('Json is not supported as output format.');
+    return response;
+  }
+
+  if (request.getRequestedOutputFormat() === WireFormat.TEXT_FORMAT) {
+    response.setSkipped('Text format is not supported as output format.');
+    return response;
+  }
+
+  if (request.getRequestedOutputFormat() === WireFormat.TEXT_FORMAT) {
+    response.setRuntimeError('Unspecified output format');
+    return response;
+  }
+
+  if (request.getRequestedOutputFormat() !== WireFormat.PROTOBUF) {
+    throw new Error('Request didn\'t have accepted output format.');
+  }
+
+  if (request.getMessageType() === 'conformance.FailureSet') {
+    response.setProtobufPayload(new ArrayBuffer(0));
+  } else if (
+      request.getMessageType() ===
+      'protobuf_test_messages.proto2.TestAllTypesProto2') {
+    try {
+      const testMessage =
+          TestAllTypesProto2.deserialize(request.getProtobufPayload());
+      response.setProtobufPayload(testMessage.serialize());
+    } catch (err) {
+      response.setParseError(err.toString());
+    }
+  } else if (
+      request.getMessageType() ===
+      'protobuf_test_messages.proto3.TestAllTypesProto3') {
+    try {
+      const testMessage =
+          TestAllTypesProto3.deserialize(request.getProtobufPayload());
+      response.setProtobufPayload(testMessage.serialize());
+    } catch (err) {
+      response.setParseError(err.toString());
+    }
+  } else {
+    throw new Error(
+        `Payload message not supported: ${request.getMessageType()}.`);
+  }
+
+  return response;
+}
+
+/**
+ * Same as doTest, but both request and response are in base64.
+ * @param {string} base64Request
+ * @return {string} response
+ */
+function runConformanceTest(base64Request) {
+  const request =
+      ConformanceRequest.deserialize(
+          base64.decodeStringToUint8Array(base64Request).buffer);
+  const response = doTest(request);
+  return base64.encodeByteArray(new Uint8Array(response.serialize()));
+}
+
+// Needed for node test
+exports.doTest = doTest;
+// Needed for browser test
+goog.exportSymbol('runConformanceTest', runConformanceTest);

deps/protobuf/js/experimental/runtime/kernel/conformance/conformance_testee_runner_node.js

@@ -0,0 +1,62 @@
+const ConformanceRequest = goog.require('proto.conformance.ConformanceRequest');
+const {doTest} = goog.require('javascript.protobuf.conformance');
+const fs = require('fs');
+
+
+/**
+ * Reads a buffer of N bytes.
+ * @param {number} bytes Number of bytes to read.
+ * @return {!Buffer} Buffer which contains data.
+ */
+function readBuffer(bytes) {
+  // Linux cannot use process.stdin.fd (which isn't set up as sync)
+  const buf = new Buffer.alloc(bytes);
+  const fd = fs.openSync('/dev/stdin', 'r');
+  fs.readSync(fd, buf, 0, bytes);
+  fs.closeSync(fd);
+  return buf;
+}
+
+/**
+ * Writes all data in buffer.
+ * @param {!Buffer} buffer Buffer which contains data.
+ */
+function writeBuffer(buffer) {
+  // Under linux, process.stdout.fd is async. Needs to open stdout in a synced
+  // way for sync write.
+  const fd = fs.openSync('/dev/stdout', 'w');
+  fs.writeSync(fd, buffer, 0, buffer.length);
+  fs.closeSync(fd);
+}
+
+/**
+ * Returns true if the test ran successfully, false on legitimate EOF.
+ * @return {boolean} Whether to continue test.
+ */
+function runConformanceTest() {
+  const requestLengthBuf = readBuffer(4);
+  const requestLength = requestLengthBuf.readInt32LE(0);
+  if (!requestLength) {
+    return false;
+  }
+
+  const serializedRequest = readBuffer(requestLength);
+  const array = new Uint8Array(serializedRequest);
+  const request = ConformanceRequest.deserialize(array.buffer);
+  const response = doTest(request);
+
+  const serializedResponse = response.serialize();
+
+  const responseLengthBuf = new Buffer.alloc(4);
+  responseLengthBuf.writeInt32LE(serializedResponse.byteLength, 0);
+  writeBuffer(responseLengthBuf);
+  writeBuffer(new Buffer.from(serializedResponse));
+
+  return true;
+}
+
+while (true) {
+  if (!runConformanceTest()) {
+    break;
+  }
+}

deps/protobuf/js/experimental/runtime/kernel/conformance/test_all_types_proto2.js

@@ -0,0 +1,309 @@
+/**
+ * @fileoverview Handwritten code of TestAllTypesProto2.
+ */
+goog.module('proto.conformance.TestAllTypesProto2');
+
+const InternalMessage = goog.require('protobuf.binary.InternalMessage');
+const Kernel = goog.require('protobuf.runtime.Kernel');
+
+/**
+ * Handwritten code of conformance.TestAllTypesProto2.
+ * Check google/protobuf/test_messages_proto3.proto for more details.
+ * @implements {InternalMessage}
+ * @final
+ */
+class TestAllTypesProto2 {
+  /**
+   * @param {!Kernel=} accessor
+   * @private
+   */
+  constructor(accessor = Kernel.createEmpty()) {
+    /** @private @const {!Kernel} */
+    this.accessor_ = accessor;
+  }
+
+  /**
+   * @override
+   * @package
+   * @return {!Kernel}
+   */
+  internalGetKernel() {
+    return this.accessor_;
+  }
+
+  /**
+   * Create a request instance with the given bytes data.
+   * If we directly use the accessor created by the binary decoding, the
+   * Kernel instance will only copy the same data over for encoding.  By
+   * explicitly fetching data from the previous accessor and setting all fields
+   * into a new accessor, we will actually test encoding/decoding for the binary
+   * format.
+   * @param {!ArrayBuffer} bytes
+   * @return {!TestAllTypesProto2}
+   */
+  static deserialize(bytes) {
+    const msg = new TestAllTypesProto2();
+    const requestAccessor = Kernel.fromArrayBuffer(bytes);
+
+    if (requestAccessor.hasFieldNumber(1)) {
+      const value = requestAccessor.getInt32WithDefault(1);
+      msg.accessor_.setInt32(1, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(2)) {
+      const value = requestAccessor.getInt64WithDefault(2);
+      msg.accessor_.setInt64(2, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(3)) {
+      const value = requestAccessor.getUint32WithDefault(3);
+      msg.accessor_.setUint32(3, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(4)) {
+      const value = requestAccessor.getUint64WithDefault(4);
+      msg.accessor_.setUint64(4, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(5)) {
+      const value = requestAccessor.getSint32WithDefault(5);
+      msg.accessor_.setSint32(5, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(6)) {
+      const value = requestAccessor.getSint64WithDefault(6);
+      msg.accessor_.setSint64(6, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(7)) {
+      const value = requestAccessor.getFixed32WithDefault(7);
+      msg.accessor_.setFixed32(7, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(8)) {
+      const value = requestAccessor.getFixed64WithDefault(8);
+      msg.accessor_.setFixed64(8, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(9)) {
+      const value = requestAccessor.getSfixed32WithDefault(9);
+      msg.accessor_.setSfixed32(9, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(10)) {
+      const value = requestAccessor.getSfixed64WithDefault(10);
+      msg.accessor_.setSfixed64(10, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(11)) {
+      const value = requestAccessor.getFloatWithDefault(11);
+      msg.accessor_.setFloat(11, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(12)) {
+      const value = requestAccessor.getDoubleWithDefault(12);
+      msg.accessor_.setDouble(12, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(13)) {
+      const value = requestAccessor.getBoolWithDefault(13);
+      msg.accessor_.setBool(13, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(14)) {
+      const value = requestAccessor.getStringWithDefault(14);
+      msg.accessor_.setString(14, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(15)) {
+      const value = requestAccessor.getBytesWithDefault(15);
+      msg.accessor_.setBytes(15, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(18)) {
+      const value = requestAccessor.getMessage(
+          18, (accessor) => new TestAllTypesProto2(accessor));
+      msg.accessor_.setMessage(18, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(21)) {
+      // Unknown enum is not checked here, because even if an enum is unknown,
+      // it should be kept during encoding. For the purpose of wire format test,
+      // we can simplify the implementation by treating it as an int32 field,
+      // which has the same semantic except for the unknown value checking.
+      const value = requestAccessor.getInt32WithDefault(21);
+      msg.accessor_.setInt32(21, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(31)) {
+      const value = requestAccessor.getRepeatedInt32Iterable(31);
+      msg.accessor_.setUnpackedInt32Iterable(31, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(32)) {
+      const value = requestAccessor.getRepeatedInt64Iterable(32);
+      msg.accessor_.setUnpackedInt64Iterable(32, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(33)) {
+      const value = requestAccessor.getRepeatedUint32Iterable(33);
+      msg.accessor_.setUnpackedUint32Iterable(33, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(34)) {
+      const value = requestAccessor.getRepeatedUint64Iterable(34);
+      msg.accessor_.setUnpackedUint64Iterable(34, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(35)) {
+      const value = requestAccessor.getRepeatedSint32Iterable(35);
+      msg.accessor_.setUnpackedSint32Iterable(35, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(36)) {
+      const value = requestAccessor.getRepeatedSint64Iterable(36);
+      msg.accessor_.setUnpackedSint64Iterable(36, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(37)) {
+      const value = requestAccessor.getRepeatedFixed32Iterable(37);
+      msg.accessor_.setUnpackedFixed32Iterable(37, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(38)) {
+      const value = requestAccessor.getRepeatedFixed64Iterable(38);
+      msg.accessor_.setUnpackedFixed64Iterable(38, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(39)) {
+      const value = requestAccessor.getRepeatedSfixed32Iterable(39);
+      msg.accessor_.setUnpackedSfixed32Iterable(39, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(40)) {
+      const value = requestAccessor.getRepeatedSfixed64Iterable(40);
+      msg.accessor_.setUnpackedSfixed64Iterable(40, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(41)) {
+      const value = requestAccessor.getRepeatedFloatIterable(41);
+      msg.accessor_.setUnpackedFloatIterable(41, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(42)) {
+      const value = requestAccessor.getRepeatedDoubleIterable(42);
+      msg.accessor_.setUnpackedDoubleIterable(42, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(43)) {
+      const value = requestAccessor.getRepeatedBoolIterable(43);
+      msg.accessor_.setUnpackedBoolIterable(43, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(44)) {
+      const value = requestAccessor.getRepeatedStringIterable(44);
+      msg.accessor_.setRepeatedStringIterable(44, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(45)) {
+      const value = requestAccessor.getRepeatedBytesIterable(45);
+      msg.accessor_.setRepeatedBytesIterable(45, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(48)) {
+      const value = requestAccessor.getRepeatedMessageIterable(
+          48, (accessor) => new TestAllTypesProto2(accessor));
+      msg.accessor_.setRepeatedMessageIterable(48, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(51)) {
+      // Unknown enum is not checked here, because even if an enum is unknown,
+      // it should be kept during encoding. For the purpose of wire format test,
+      // we can simplify the implementation by treating it as an int32 field,
+      // which has the same semantic except for the unknown value checking.
+      const value = requestAccessor.getRepeatedInt32Iterable(51);
+      msg.accessor_.setUnpackedInt32Iterable(51, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(75)) {
+      const value = requestAccessor.getRepeatedInt32Iterable(75);
+      msg.accessor_.setPackedInt32Iterable(75, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(76)) {
+      const value = requestAccessor.getRepeatedInt64Iterable(76);
+      msg.accessor_.setPackedInt64Iterable(76, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(77)) {
+      const value = requestAccessor.getRepeatedUint32Iterable(77);
+      msg.accessor_.setPackedUint32Iterable(77, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(78)) {
+      const value = requestAccessor.getRepeatedUint64Iterable(78);
+      msg.accessor_.setPackedUint64Iterable(78, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(79)) {
+      const value = requestAccessor.getRepeatedSint32Iterable(79);
+      msg.accessor_.setPackedSint32Iterable(79, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(80)) {
+      const value = requestAccessor.getRepeatedSint64Iterable(80);
+      msg.accessor_.setPackedSint64Iterable(80, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(81)) {
+      const value = requestAccessor.getRepeatedFixed32Iterable(81);
+      msg.accessor_.setPackedFixed32Iterable(81, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(82)) {
+      const value = requestAccessor.getRepeatedFixed64Iterable(82);
+      msg.accessor_.setPackedFixed64Iterable(82, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(83)) {
+      const value = requestAccessor.getRepeatedSfixed32Iterable(83);
+      msg.accessor_.setPackedSfixed32Iterable(83, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(84)) {
+      const value = requestAccessor.getRepeatedSfixed64Iterable(84);
+      msg.accessor_.setPackedSfixed64Iterable(84, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(85)) {
+      const value = requestAccessor.getRepeatedFloatIterable(85);
+      msg.accessor_.setPackedFloatIterable(85, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(86)) {
+      const value = requestAccessor.getRepeatedDoubleIterable(86);
+      msg.accessor_.setPackedDoubleIterable(86, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(87)) {
+      const value = requestAccessor.getRepeatedBoolIterable(87);
+      msg.accessor_.setPackedBoolIterable(87, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(88)) {
+      const value = requestAccessor.getRepeatedInt32Iterable(88);
+      msg.accessor_.setPackedInt32Iterable(88, value);
+    }
+    return msg;
+  }
+
+  /**
+   * Serializes into binary data.
+   * @return {!ArrayBuffer}
+   */
+  serialize() {
+    return this.accessor_.serialize();
+  }
+}
+
+exports = TestAllTypesProto2;

deps/protobuf/js/experimental/runtime/kernel/conformance/test_all_types_proto3.js

@@ -0,0 +1,310 @@
+/**
+ * @fileoverview Handwritten code of TestAllTypesProto3.
+ */
+goog.module('proto.conformance.TestAllTypesProto3');
+
+const InternalMessage = goog.require('protobuf.binary.InternalMessage');
+const Kernel = goog.require('protobuf.runtime.Kernel');
+
+/**
+ * Handwritten code of conformance.TestAllTypesProto3.
+ * Check google/protobuf/test_messages_proto3.proto for more details.
+ * @implements {InternalMessage}
+ * @final
+ */
+class TestAllTypesProto3 {
+  /**
+   * @param {!Kernel=} accessor
+   * @private
+   */
+  constructor(accessor = Kernel.createEmpty()) {
+    /** @private @const {!Kernel} */
+    this.accessor_ = accessor;
+  }
+
+  /**
+   * @override
+   * @package
+   * @return {!Kernel}
+   */
+  internalGetKernel() {
+    return this.accessor_;
+  }
+
+  /**
+   * Create a request instance with the given bytes data.
+   * If we directly use the accessor created by the binary decoding, the
+   * Kernel instance will only copy the same data over for encoding.  By
+   * explicitly fetching data from the previous accessor and setting all fields
+   * into a new accessor, we will actually test encoding/decoding for the binary
+   * format.
+   * @param {!ArrayBuffer} bytes
+   * @return {!TestAllTypesProto3}
+   */
+  static deserialize(bytes) {
+    const msg = new TestAllTypesProto3();
+    const requestAccessor = Kernel.fromArrayBuffer(bytes);
+
+    if (requestAccessor.hasFieldNumber(1)) {
+      const value = requestAccessor.getInt32WithDefault(1);
+      msg.accessor_.setInt32(1, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(2)) {
+      const value = requestAccessor.getInt64WithDefault(2);
+      msg.accessor_.setInt64(2, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(3)) {
+      const value = requestAccessor.getUint32WithDefault(3);
+      msg.accessor_.setUint32(3, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(4)) {
+      const value = requestAccessor.getUint64WithDefault(4);
+      msg.accessor_.setUint64(4, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(5)) {
+      const value = requestAccessor.getSint32WithDefault(5);
+      msg.accessor_.setSint32(5, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(6)) {
+      const value = requestAccessor.getSint64WithDefault(6);
+      msg.accessor_.setSint64(6, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(7)) {
+      const value = requestAccessor.getFixed32WithDefault(7);
+      msg.accessor_.setFixed32(7, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(8)) {
+      const value = requestAccessor.getFixed64WithDefault(8);
+      msg.accessor_.setFixed64(8, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(9)) {
+      const value = requestAccessor.getSfixed32WithDefault(9);
+      msg.accessor_.setSfixed32(9, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(10)) {
+      const value = requestAccessor.getSfixed64WithDefault(10);
+      msg.accessor_.setSfixed64(10, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(11)) {
+      const value = requestAccessor.getFloatWithDefault(11);
+      msg.accessor_.setFloat(11, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(12)) {
+      const value = requestAccessor.getDoubleWithDefault(12);
+      msg.accessor_.setDouble(12, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(13)) {
+      const value = requestAccessor.getBoolWithDefault(13);
+      msg.accessor_.setBool(13, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(14)) {
+      const value = requestAccessor.getStringWithDefault(14);
+      msg.accessor_.setString(14, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(15)) {
+      const value = requestAccessor.getBytesWithDefault(15);
+      msg.accessor_.setBytes(15, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(18)) {
+      const value = requestAccessor.getMessage(
+          18, (accessor) => new TestAllTypesProto3(accessor));
+      msg.accessor_.setMessage(18, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(21)) {
+      // Unknown enum is not checked here, because even if an enum is unknown,
+      // it should be kept during encoding. For the purpose of wire format test,
+      // we can simplify the implementation by treating it as an int32 field,
+      // which has the same semantic except for the unknown value checking.
+      const value = requestAccessor.getInt32WithDefault(21);
+      msg.accessor_.setInt32(21, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(31)) {
+      const value = requestAccessor.getRepeatedInt32Iterable(31);
+      msg.accessor_.setPackedInt32Iterable(31, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(32)) {
+      const value = requestAccessor.getRepeatedInt64Iterable(32);
+      msg.accessor_.setPackedInt64Iterable(32, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(33)) {
+      const value = requestAccessor.getRepeatedUint32Iterable(33);
+      msg.accessor_.setPackedUint32Iterable(33, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(34)) {
+      const value = requestAccessor.getRepeatedUint64Iterable(34);
+      msg.accessor_.setPackedUint64Iterable(34, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(35)) {
+      const value = requestAccessor.getRepeatedSint32Iterable(35);
+      msg.accessor_.setPackedSint32Iterable(35, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(36)) {
+      const value = requestAccessor.getRepeatedSint64Iterable(36);
+      msg.accessor_.setPackedSint64Iterable(36, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(37)) {
+      const value = requestAccessor.getRepeatedFixed32Iterable(37);
+      msg.accessor_.setPackedFixed32Iterable(37, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(38)) {
+      const value = requestAccessor.getRepeatedFixed64Iterable(38);
+      msg.accessor_.setPackedFixed64Iterable(38, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(39)) {
+      const value = requestAccessor.getRepeatedSfixed32Iterable(39);
+      msg.accessor_.setPackedSfixed32Iterable(39, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(40)) {
+      const value = requestAccessor.getRepeatedSfixed64Iterable(40);
+      msg.accessor_.setPackedSfixed64Iterable(40, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(41)) {
+      const value = requestAccessor.getRepeatedFloatIterable(41);
+      msg.accessor_.setPackedFloatIterable(41, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(42)) {
+      const value = requestAccessor.getRepeatedDoubleIterable(42);
+      msg.accessor_.setPackedDoubleIterable(42, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(43)) {
+      const value = requestAccessor.getRepeatedBoolIterable(43);
+      msg.accessor_.setPackedBoolIterable(43, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(44)) {
+      const value = requestAccessor.getRepeatedStringIterable(44);
+      msg.accessor_.setRepeatedStringIterable(44, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(45)) {
+      const value = requestAccessor.getRepeatedBytesIterable(45);
+      msg.accessor_.setRepeatedBytesIterable(45, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(48)) {
+      const value = requestAccessor.getRepeatedMessageIterable(
+          48, (accessor) => new TestAllTypesProto3(accessor));
+      msg.accessor_.setRepeatedMessageIterable(48, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(51)) {
+      // Unknown enum is not checked here, because even if an enum is unknown,
+      // it should be kept during encoding. For the purpose of wire format test,
+      // we can simplify the implementation by treating it as an int32 field,
+      // which has the same semantic except for the unknown value checking.
+      const value = requestAccessor.getRepeatedInt32Iterable(51);
+      msg.accessor_.setPackedInt32Iterable(51, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(89)) {
+      const value = requestAccessor.getRepeatedInt32Iterable(89);
+      msg.accessor_.setUnpackedInt32Iterable(89, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(90)) {
+      const value = requestAccessor.getRepeatedInt64Iterable(90);
+      msg.accessor_.setUnpackedInt64Iterable(90, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(91)) {
+      const value = requestAccessor.getRepeatedUint32Iterable(91);
+      msg.accessor_.setUnpackedUint32Iterable(91, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(92)) {
+      const value = requestAccessor.getRepeatedUint64Iterable(92);
+      msg.accessor_.setUnpackedUint64Iterable(92, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(93)) {
+      const value = requestAccessor.getRepeatedSint32Iterable(93);
+      msg.accessor_.setUnpackedSint32Iterable(93, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(94)) {
+      const value = requestAccessor.getRepeatedSint64Iterable(94);
+      msg.accessor_.setUnpackedSint64Iterable(94, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(95)) {
+      const value = requestAccessor.getRepeatedFixed32Iterable(95);
+      msg.accessor_.setUnpackedFixed32Iterable(95, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(96)) {
+      const value = requestAccessor.getRepeatedFixed64Iterable(96);
+      msg.accessor_.setUnpackedFixed64Iterable(96, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(97)) {
+      const value = requestAccessor.getRepeatedSfixed32Iterable(97);
+      msg.accessor_.setUnpackedSfixed32Iterable(97, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(98)) {
+      const value = requestAccessor.getRepeatedSfixed64Iterable(98);
+      msg.accessor_.setUnpackedSfixed64Iterable(98, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(99)) {
+      const value = requestAccessor.getRepeatedFloatIterable(99);
+      msg.accessor_.setUnpackedFloatIterable(99, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(100)) {
+      const value = requestAccessor.getRepeatedDoubleIterable(100);
+      msg.accessor_.setUnpackedDoubleIterable(100, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(101)) {
+      const value = requestAccessor.getRepeatedBoolIterable(101);
+      msg.accessor_.setUnpackedBoolIterable(101, value);
+    }
+
+    if (requestAccessor.hasFieldNumber(102)) {
+      const value = requestAccessor.getRepeatedInt32Iterable(102);
+      msg.accessor_.setUnpackedInt32Iterable(102, value);
+    }
+
+    return msg;
+  }
+
+  /**
+   * Serializes into binary data.
+   * @return {!ArrayBuffer}
+   */
+  serialize() {
+    return this.accessor_.serialize();
+  }
+}
+
+exports = TestAllTypesProto3;

deps/protobuf/js/experimental/runtime/kernel/conformance/wire_format.js

@@ -0,0 +1,16 @@
+/**
+ * @fileoverview Handwritten code of WireFormat.
+ */
+goog.module('proto.conformance.WireFormat');
+
+/**
+ * @enum {number}
+ */
+const WireFormat = {
+  UNSPECIFIED: 0,
+  PROTOBUF: 1,
+  JSON: 2,
+  TEXT_FORMAT: 4,
+};
+
+exports = WireFormat;