enc := NewEncoder(&buf)
			r := struct{ io.Reader }{bytes.NewReader(input)} // io.Reader only; not io.WriterTo
			if n, err := io.CopyBuffer(enc, r, make([]byte, 7)); n != int64(len(input)) || err != nil {
				t.Errorf("encoder.Write(%q*%d) = (%d, %v), want (%d, nil)", test.dec, multiplier, n, err, len(input))
				continue
			}

			if encDst := buf.String(); encDst != output {

	}
}

var encoders = []struct {
	name string
	fn   func(order ByteOrder, data any) ([]byte, error)
}{
	{
		"Write",
		func(order ByteOrder, data any) ([]byte, error) {
			buf := new(bytes.Buffer)
			err := Write(buf, order, data)
			return buf.Bytes(), err
		},
	},
	{
		"Encode",
		func(order ByteOrder, data any) ([]byte, error) {

	)

	// Add missing query parameters if any provided in the request URL
	for k, v := range req.Form {
		if !defaultSigParams.Contains(k) {
			query[k] = v
		}
	}

	// Get the encoded query.
	encodedQuery := query.Encode()

	// Verify if date query is same.
	if req.Form.Get(xhttp.AmzDate) != query.Get(xhttp.AmzDate) {
		return ErrSignatureDoesNotMatch
	}
	// Verify if expires query is same.

        }

        @Override
        public void write(Encoder encoder, Map<String, String> value) throws Exception {
            encoder.writeSmallInt(value.size());
            for (Map.Entry<String, String> entry : value.entrySet()) {
                encoder.writeString(entry.getKey());
                encoder.writeString(entry.getValue());
            }
        }
    }

            writeConfiguration(encoder, configuration);
            writeFiles(encoder, configuration.getArtifacts());
            writeDependencies(encoder, configuration, deduplicationDependencyCache);
        }
    }

    protected void writeConfiguration(Encoder encoder, ConfigurationMetadata configuration) throws IOException {
        assert configuration != null;
        encoder.writeString(configuration.getName());

        @Override
        public void write(Encoder encoder, DefaultTestFailure value) throws Exception {
            encoder.writeNullableString(value.getDetails().getMessage());
            encoder.writeString(value.getDetails().getClassName());
            encoder.writeString(value.getDetails().getStacktrace());
            encoder.writeBoolean(value.getDetails().isAssertionFailure());

        encoder.writeString(group);
        encoder.writeString(module);
        writeVersionConstraint(encoder, version);
        writeAttributes(encoder, attributes);
        writeCapabilities(encoder, capabilities);
    }

        }
    }

    private void writeAttributes(Encoder encoder, AttributeContainer attributes) throws IOException {
        attributeContainerSerializer.write(encoder, attributes);
    }

    private void writeVersionConstraint(Encoder encoder, VersionConstraint versionConstraint) throws IOException {
        encoder.writeString(versionConstraint.getRequiredVersion());
        encoder.writeString(versionConstraint.getPreferredVersion());

            protected void writeAdditionalData(Encoder encoder, ImplementationSnapshot implementationSnapshot) throws Exception {
                LambdaImplementationSnapshot serLambda = (LambdaImplementationSnapshot) implementationSnapshot;
                hashCodeSerializer.write(encoder, serLambda.getClassLoaderHash());
                encoder.writeString(serLambda.getFunctionalInterfaceClass());
                encoder.writeString(serLambda.getImplClass());

            successful
        );
    }

    @Override
    public void write(Encoder encoder, PreviousExecutionState execution) throws Exception {
        originMetadataSerializer.write(encoder, execution.getOriginMetadata());

        hashCodeSerializer.write(encoder, execution.getCacheKey());
        implementationSnapshotSerializer.write(encoder, execution.getImplementation());