testRemaining{6, 3},
			testReadFrom{fileOps{int64(3), "cde"}, 6, nil},
			testRemaining{0, 0},
		},
	}, {
		maker: makeSparse{makeReg{5, "abcde"}, sparseHoles{{2, 3}}, 8},
		tests: []testFnc{
			testReadFrom{fileOps{"ab", int64(3), "cde"}, 8, nil},
			testRemaining{0, 0},
		},
	}, {
		maker: makeSparse{makeReg{5, "abcde"}, sparseHoles{{2, 3}}, 8},
		tests: []testFnc{

    assertEqualCharNodes(traverser.breadthFirst(charactersOf("bc")), "bcda");
  }

  @Test
  public void forGraph_breadthFirst_twoCycles() {
    Traverser<Character> traverser = Traverser.forGraph(TWO_CYCLES_GRAPH);
    assertEqualCharNodes(traverser.breadthFirst('a'), "abcd");
    assertEqualCharNodes(traverser.breadthFirst('b'), "bcda");
    assertEqualCharNodes(traverser.breadthFirst('c'), "cdab");

			testRead{0, "", io.EOF},
		},
	}, {
		maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{0, 2}, {5, 3}}, 8},
		tests: []testFnc{
			testRemaining{8, 5},
			testRead{3, "ab\x00", nil},
			testRead{10, "\x00\x00cde", io.EOF},
			testRemaining{0, 0},
		},
	}, {
		maker: makeSparse{makeReg{"abcde", 5}, sparseDatas{{0, 2}, {5, 3}}, 8},
		tests: []testFnc{
			testRemaining{8, 5},

    java.net.Authenticator.setDefault(null)
  }

  @Test
  fun get() {
    server.enqueue(MockResponse(body = "ABCDE"))
    val call = client.newCall(Request(server.url("/foo")))
    val response = call.execute()
    assertThat(response.body.string()).isEqualTo("ABCDE")
    assertThat(response.code).isEqualTo(200)
    assertThat(response.message).isEqualTo("")
    assertThat(response.protocol).isEqualTo(protocol)

        // Test case 2: Single padding
        final byte[] data2 = "abcd".getBytes();
        assertEquals("YWJjZA==", Base64Util.encode(data2));

        // Test case 3: Double padding
        final byte[] data3 = "abcde".getBytes();
        assertEquals("YWJjZGU=", Base64Util.encode(data3));

        // Test case 4: No padding
        final byte[] data4 = "abcdef".getBytes();
        assertEquals("YWJjZGVm", Base64Util.encode(data4));

    transferKind.setBody(mockResponse, "ABCDE\nFGHIJKLMNOPQRSTUVWXYZ", 16)
    server.enqueue(truncateViolently(mockResponse, 16).build())
    server.enqueue(
      MockResponse
        .Builder()
        .body("Request #2")
        .build(),
    )
    val bodySource = get(server.url("/")).body.source()
    assertThat(bodySource.readUtf8Line()).isEqualTo("ABCDE")
    bodySource.use {

    assertEquals(2, CharStreams.readLines(r, conditional).intValue());
    assertEquals("ab", sb.toString());
  }

  public void testSkipFully_eof() throws IOException {
    Reader reader = new StringReader("abcde");
    assertThrows(EOFException.class, () -> CharStreams.skipFully(reader, 6));
  }

  public void testSkipFully() throws IOException {
    String testString = "abcdef";

    assertEquals(2, CharStreams.readLines(r, conditional).intValue());
    assertEquals("ab", sb.toString());
  }

  public void testSkipFully_eof() throws IOException {
    Reader reader = new StringReader("abcde");
    assertThrows(EOFException.class, () -> CharStreams.skipFully(reader, 6));
  }

  public void testSkipFully() throws IOException {
    String testString = "abcdef";

                    final CycleDetectedException cde = (CycleDetectedException) cycle.getException();
                    throw new ProjectBuildingException(
                            null,
                            "The projects in the reactor contain a cyclic reference: " + cycle.getMessage(),
                            null,
                            cde);
                }

    //     the smaller of these blocks with the far end of the other one. That leaves us with a
    //     smaller version of the same problem.
    //     Say we are rotating abcdefgh by 5. We start with abcde|fgh. The smaller block is [fgh]:
    //     [abc]de|[fgh] -> [fgh]de|[abc]. Now [fgh] is in the right place, but we need to swap [de]
    //     with [abc]: fgh[de]|a[bc] -> fgh[bc]|a[de]. Now we need to swap [a] with [bc]: