for input.Scan() {
		line := strings.TrimSpace(input.Text())
		if line == "" {
			continue
		}
		// Find first separator.
		idx := strings.IndexByte(line, trailerKVSeparator[0])
		if idx <= 0 || idx >= len(line) {
			if cr.debug {
				fmt.Printf("Could not find separator, got %q\n", line)
			}
			return errMalformedEncoding
		}
		key := strings.ToLower(line[:idx])

package cmd

import (
	"bytes"
	"context"
	"crypto/rand"
	"io"
	"testing"

	"github.com/dustin/go-humanize"
)

type badDisk struct{ StorageAPI }

func (a badDisk) String() string {
	return "bad-disk"
}

func (a badDisk) AppendFile(ctx context.Context, volume string, path string, buf []byte) error {
	return errFaultyDisk
}

     */
    public static int enc_uint32le(final int i, final byte[] dst, int di) {
        dst[di] = (byte) (i & 0xFF);
        di++;
        dst[di++] = (byte) (i >> 8 & 0xFF);
        dst[di++] = (byte) (i >> 16 & 0xFF);
        dst[di] = (byte) (i >> 24 & 0xFF);
        return 4;
    }

    /* Decode integers
     */

    /**

    }

    /**
     * Gets the server's NTLM challenge bytes.
     * @return the server challenge bytes
     */
    public byte[] getServerChallenge() {
        return serverChallenge;
    }

    /**
     * Gets the signing key for message authentication.
     * @return the signing key bytes
     */
    public byte[] getSigningKey() {
        return signingKey;
    }

    /**

    }
  }

  /** Encodes the specified byte array, and returns the encoded {@code String}. */
  public String encode(byte[] bytes) {
    return encode(bytes, 0, bytes.length);
  }

  /**
   * Encodes the specified range of the specified byte array, and returns the encoded {@code
   * String}.
   */
  public final String encode(byte[] bytes, int off, int len) {

package csv

import (
	"bytes"
	"io"
)

// recordTransform will convert records to always have newline records.
type recordTransform struct {
	reader io.Reader
	// recordDelimiter can be up to 2 characters.
	recordDelimiter []byte
	oneByte         []byte
	useOneByte      bool
}

func (rr *recordTransform) Read(p []byte) (n int, err error) {
	if rr.useOneByte {
		p[0] = rr.oneByte[0]

				}
			}
			var stdBuf bytes.Buffer
			w := s2.NewWriter(&stdBuf)
			_, err = io.CopyBuffer(w, bytes.NewReader(tt.data), buf)
			if err != nil {
				t.Fatal(err)
			}
			err = w.Close()
			if err != nil {
				t.Fatal(err)
			}

			var (
				got  = rdrBuf.Bytes()
				want = stdBuf.Bytes()
			)
			if !bytes.Equal(got, want) {

import java.io.OutputStream;

/**
 * An OutputStream that counts the number of bytes written.
 *
 * @author Chris Nokleberg
 * @since 1.0
 */
@J2ktIncompatible
@GwtIncompatible
public final class CountingOutputStream extends FilterOutputStream {

  private long count;

  /**
   * Wraps another output stream, counting the number of bytes written.
   *
   * @param out the output stream to be wrapped
   */

		t.Fatal(err)
	}

	// Corrupted XML
	malformedReq := &http.Request{
		Body:          io.NopCloser(bytes.NewReader([]byte("<>"))),
		ContentLength: int64(len("<>")),
	}

	// Not an XML
	badRequest := &http.Request{
		Body:          io.NopCloser(bytes.NewReader([]byte("garbage"))),
		ContentLength: int64(len("garbage")),
	}

}

func plistExtract(fname string, path string) ([]byte, error) {
	out, err := exec.Command("/usr/libexec/PlistBuddy", "-c", "Print "+path, fname).CombinedOutput()
	if err != nil {
		return nil, err
	}
	return bytes.TrimSpace(out), nil
}

func getLines(cmd *exec.Cmd) [][]byte {
	out := output(cmd)
	lines := bytes.Split(out, []byte("\n"))
	// Skip the empty line at the end.