@Test
    @DisplayName("writeParameterWordsWireFormat returns zero bytes written")
    void testWriteParameterWordsWireFormat() {
        byte[] buf = new byte[10];
        assertEquals(0, response.writeParameterWordsWireFormat(buf, 0), "Should write 0 bytes");
    }

    @Test
    @DisplayName("writeParameterWordsWireFormat with null buffer - returns zero")

package tar_test

import (
	"archive/tar"
	"bytes"
	"fmt"
	"io"
	"log"
	"os"
)

func Example_minimal() {
	// Create and add some files to the archive.
	var buf bytes.Buffer
	tw := tar.NewWriter(&buf)
	var files = []struct {
		Name, Body string
	}{
		{"readme.txt", "This archive contains some text files."},
		{"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"},

        final StringBuilder buf = new StringBuilder(100);
        buf.append("/WEB-INF/view/").append(page);
        if (StringUtil.isNotBlank(lang)) {
            buf.append('_').append(lang);
            if (StringUtil.isNotBlank(country)) {
                buf.append('_').append(country);
            }
        }
        buf.append(".jsp");
        return buf.toString();
    }

    /**

    for (i in s.indices) {
      assertRoundTrip(s.substring(0, i).encodeUtf8())
    }
    val random = Random(123456789L)
    val buf = ByteArray(4096)
    random.nextBytes(buf)
    assertRoundTrip(buf.toByteString())
  }

  private fun assertRoundTrip(data: ByteString) {
    val encodeBuffer = Buffer()
    encode(data, encodeBuffer)

     */
    public static String create() {
        final StringBuilder buf = new StringBuilder(BASE.length() * 2);
        buf.append(BASE);
        final int lowTime = (int) (System.currentTimeMillis() >> 32);
        StringUtil.appendHex(buf, lowTime);
        StringUtil.appendHex(buf, RANDOM.nextInt());
        return buf.toString();
    }

    private static byte[] getAddress() {
        try {

    OLD {
      @Override
      long copy(Readable from, Appendable to) throws IOException {
        CharBuffer buf = CharStreams.createBuffer();
        long total = 0;
        while (from.read(buf) != -1) {
          ((Buffer) buf).flip();
          to.append(buf);
          total += buf.remaining();
          ((Buffer) buf).clear();
        }
        return total;
      }
    },
    NEW {
      @Override

				}
			})
			b.Run("ToFileInfoNew", func(b *testing.B) {
				b.SetBytes(int64(size))
				b.ResetTimer()
				b.ReportAllocs()
				for b.Loop() {
					buf, _, _ := isIndexedMetaV2(enc)
					if buf == nil {
						b.Fatal("buf == nil")
					}
					_, err = buf.ToFileInfo("volume", "path", ids[rng.Intn(size)], true)
					if err != nil {
						b.Fatal(err)
					}
				}
			})

// drain returns a single string representing the processed input tokens.
func drain(input *Input) string {
	var buf strings.Builder
	for {
		tok := input.Next()
		if tok == scanner.EOF {
			return buf.String()
		}
		if tok == '#' {
			continue
		}
		if buf.Len() > 0 {
			buf.WriteByte('.')
		}
		buf.WriteString(input.Text())
	}
}

type badLexTest struct {
	input string
	error string
}

}

// AppendFile - append to a file.
func (client *storageRESTClient) AppendFile(ctx context.Context, volume string, path string, buf []byte) error {
	values := make(url.Values)
	values.Set(storageRESTVolume, volume)
	values.Set(storageRESTFilePath, path)
	reader := bytes.NewReader(buf)
	respBody, err := client.call(ctx, storageRESTMethodAppendFile, values, reader, -1)
	defer xhttp.DrainBody(respBody)
	return err
}

        Trans2GetDfsReferral cmd = new Trans2GetDfsReferral("foo");
        byte[] buf = new byte[2];
        int r = cmd.writeSetupWireFormat(buf, 0);
        assertEquals(2, r);
        byte subCmd = (byte) getPrivateField(cmd, "subCommand");
        assertEquals(subCmd, buf[0]);
        assertEquals((byte) 0x00, buf[1]);
    }

    @Test
    @DisplayName("writeParametersWireFormat writes referral level and path")