assertThat(peekedBody.string()).isEqualTo("abc")
    assertThat(response.body.string()).isEqualTo("abcdef")
  }

  @Test fun peekLongerThanResponse() {
    val response = newResponse(responseBody("abc"))
    val peekedBody = response.peekBody(6)
    assertThat(peekedBody.string()).isEqualTo("abc")
    assertThat(response.body.string()).isEqualTo("abc")
  }

  @Test fun eachPeakIsIndependent() {

    String simple = "abcd";
    Iterable<String> letters = Splitter.fixedLength(1).limit(100).split(simple);
    assertThat(letters).containsExactly("a", "b", "c", "d").inOrder();
  }

  public void testLimitOne() {
    String simple = "abcd";
    Iterable<String> letters = Splitter.fixedLength(1).limit(1).split(simple);
    assertThat(letters).containsExactly("abcd").inOrder();
  }

	s   string
	sep string
	n   int
	a   []string
}

var splittests = []SplitTest{
	{"", "", -1, []string{}},
	{abcd, "a", 0, nil},
	{abcd, "", 2, []string{"a", "bcd"}},
	{abcd, "a", -1, []string{"", "bcd"}},
	{abcd, "z", -1, []string{"abcd"}},
	{abcd, "", -1, []string{"a", "b", "c", "d"}},
	{commas, ",", -1, []string{"1", "2", "3", "4"}},
	{dots, "...", -1, []string{"1", ".2", ".3", ".4"}},

[
	uuid(12345778-1234-abcd-ef00-0123456789ac),
	version(1.0)
]
interface samr
{
	import "../rpc.idl";
	import "lsarpc.idl";

	typedef [v1_enum] enum {
		ACB_DISABLED               = 0x00000001, /* 1 = User account disabled */
		ACB_HOMDIRREQ              = 0x00000002, /* 1 = Home directory required */
		ACB_PWNOTREQ               = 0x00000004, /* 1 = User password not required */

    assertThat(response1.body.string()).isEqualTo("abcd")
    val response2 = get(server.url("/"))
    assertThat(response2.header("Alpha")).isEqualTo("α")
    assertThat(response2.header("β")).isEqualTo("Beta")
    assertThat(response2.header("Gamma")).isEqualTo("Γ")
    assertThat(response2.header("Δ")).isEqualTo("Delta")
    assertThat(response2.body.string()).isEqualTo("abcd")
  }

  @Test

    CharMatcher len1 = SmallCharMatcher.from(bitSet("#"), "#");
    CharMatcher len2 = SmallCharMatcher.from(bitSet("ab"), "ab");
    CharMatcher len3 = SmallCharMatcher.from(bitSet("abc"), "abc");
    CharMatcher len4 = SmallCharMatcher.from(bitSet("abcd"), "abcd");
    assertTrue(len1.matches('#'));
    assertFalse(len1.matches('!'));
    assertTrue(len2.matches('a'));
    assertTrue(len2.matches('b'));

    CharMatcher len1 = SmallCharMatcher.from(bitSet("#"), "#");
    CharMatcher len2 = SmallCharMatcher.from(bitSet("ab"), "ab");
    CharMatcher len3 = SmallCharMatcher.from(bitSet("abc"), "abc");
    CharMatcher len4 = SmallCharMatcher.from(bitSet("abcd"), "abcd");
    assertTrue(len1.matches('#'));
    assertFalse(len1.matches('!'));
    assertTrue(len2.matches('a'));
    assertTrue(len2.matches('b'));

public class PackageSanityTests extends AbstractPackageSanityTests {
  public PackageSanityTests() {
    setDefault(BaseEncoding.class, BaseEncoding.base64());
    setDefault(int.class, 32);
    setDefault(String.class, "abcd");
    setDefault(Method.class, AbstractPackageSanityTests.class.getDeclaredMethods()[0]);
    setDefault(MapMode.class, MapMode.READ_ONLY);
    setDefault(CharsetEncoder.class, UTF_8.newEncoder());
  }

	buf = NewReaderSize(dataAndEOFReader("abcd"), 32)
	if s, err := buf.Peek(2); string(s) != "ab" || err != nil {
		t.Errorf(`Peek(2) on "abcd", EOF = %q, %v; want "ab", nil`, string(s), err)
	}
	if s, err := buf.Peek(4); string(s) != "abcd" || err != nil {
		t.Errorf(`Peek(4) on "abcd", EOF = %q, %v; want "abcd", nil`, string(s), err)
	}
	if n, err := buf.Read(p[0:5]); string(p[0:n]) != "abcd" || err != nil {

[
	uuid(12345778-1234-abcd-ef00-0123456789ab),
	version(0.0)
]
interface lsarpc
{
	import "../rpc.idl";

	typedef struct {
		uint32_t length;
		uint16_t impersonation_level;
		uint8_t context_mode;
		uint8_t effective_only;
	} LsarQosInfo;

	typedef struct {
		uint32_t length;
		uint8_t *root_directory;
		unicode_string *object_name;
		uint32_t attributes;
		uint32_t security_descriptor;