configMap *v1.ConfigMap
	checksum  string
}{
	{
		desc:     "checksum is calculated using both data and binaryData",
		checksum: "sha256:c8f8b724728a6d6684106e5e64e94ce811c9965d19dd44dd073cf86cf43bc238",
		configMap: &v1.ConfigMap{
			Data: map[string]string{
				"foo": "bar",
			},
			BinaryData: map[string][]byte{
				"bar": []byte("baz"),
			},
		},
	},
	{

		}
	} else {
		for _, ktp := range mappings {
			if stringData, ok := configMap.Data[ktp.Key]; ok {
				fileProjection.Data = []byte(stringData)
			} else if binaryData, ok := configMap.BinaryData[ktp.Key]; ok {
				fileProjection.Data = binaryData
			} else {
				if optional {
					continue
				}
				return nil, fmt.Errorf("configmap references non-existent config key: %s", ktp.Key)
			}

	for _, key := range keys {
		hash.Write([]byte(cm.Data[key]))
	}

	// Do the same as above, but for binaryData this time.
	keys = []string{}
	for key := range cm.BinaryData {
		keys = append(keys, key)
	}
	sort.Strings(keys)

	for _, key := range keys {
		hash.Write(cm.BinaryData[key])
	}

	return fmt.Sprintf("sha256:%x", hash.Sum(nil))
}

    void write(WriteAction write);

    //done writing data, release any resources
    BinaryData done();

    interface WriteAction {
        void write(Encoder encoder) throws IOException;
    }

    interface ReadAction<T> {
        T read(Decoder decoder) throws IOException;
    }

    interface BinaryData extends Closeable {
        <T> T read(ReadAction<T> readAction);
    }

    private final BuildOperationExecutor buildOperationProcessor;
    private final ModuleVersionIdentifierSerializer moduleVersionIdSerializer;
    private BinaryStore.BinaryData binaryData;

    public TransientConfigurationResultsBuilder(BinaryStore binaryStore, Store<TransientConfigurationResults> cache, ImmutableModuleIdentifierFactory moduleIdentifierFactory, BuildOperationExecutor buildOperationProcessor) {

    private Encoder output = new OutputStreamBackedEncoder(bytes)

    void write(WriteAction write) {
        write.write(output)
    }

    BinaryData done() {
        new BinaryData() {
            Decoder decoder
            def <T> T read(ReadAction<T> readAction) {
                if (decoder == null) {

	}
	return b
}

// WithBinaryData puts the entries into the BinaryData field in the declarative configuration
// and returns the receiver, so that objects can be build by chaining "With" function invocations.
// If called multiple times, the entries provided by each call will be put on the BinaryData field,
// overwriting an existing map entries in BinaryData field with the same key.

    val length = 5
    val payload: ByteString = (binaryData(length))
    serverWriter.writeMessageFrame(OPCODE_TEXT, payload)
    assertData("8105")
    assertData(payload)
  }

  @Test fun serverLargeBufferedPayloadWrittenAsOneFrame() {
    val length = 12345
    val payload: ByteString = (binaryData(length))
    serverWriter.writeMessageFrame(OPCODE_TEXT, payload)
    assertData("817e")

config_path:               "/etc/istio/proxy"
binary_path:               "/usr/local/bin/envoy"
service_cluster:           "istio-proxy"
drain_duration:            {seconds: 2}
discovery_address:         "istio-pilot:15010"
proxy_admin_port:          15000
control_plane_auth_policy: NONE

config_path:               "/etc/istio/proxy"
binary_path:               "/usr/local/bin/envoy"
service_cluster:           "istio-proxy"
drain_duration:            {seconds: 2}
discovery_address:         "istio-pilot:15011"
proxy_admin_port:          15000
control_plane_auth_policy: MUTUAL_TLS