/**
 * Tests for {@link CharSequenceReader}.
 *
 * @author Colin Decker
 */
@NullUnmarked
public class CharSequenceReaderTest extends TestCase {

  public void testReadEmptyString() throws IOException {
    assertReadsCorrectly("");
  }

  public void testReadsStringsCorrectly() throws IOException {
    assertReadsCorrectly("abc");
    assertReadsCorrectly("abcde");
    assertReadsCorrectly("abcdefghijkl");

    @Test
    @DisplayName("Close delegates to underlying stream")
    void closeDelegatesToUnderlyingStream(@Mock InputStream mockIn) throws IOException {
        SocketInputStream sis = new SocketInputStream(mockIn);
        sis.close();
        verify(mockIn).close();
    }

    @Test
    @DisplayName("Read array delegates to read with offset and length")
    void readArrayDelegatesToReadWithOffsetAndLength() throws IOException {

        }

        @Override
        public void close() throws IOException {
            this.stream.close();
            this.collector.close();
        }

        @Override
        public void flush() throws IOException {
            this.stream.flush();
            this.collector.flush();
        }

        @Override
        public void write(final byte[] b) throws IOException {

            }
        }
    }

    public void test_cleanup() throws Exception {
        final String sessionId = crawler.getSessionId();

        // Add some test data
        crawler.addUrl("http://example.com/");

        // Perform cleanup - should not throw exception
        crawler.cleanup(sessionId);
    }

    public void test_stop() throws Exception {

     *            the credit to set
     */
    public final void setCredit(final int credit) {
        this.credit = credit;
    }

    /**
     * Gets the credit charge for this message.
     *
     * @return the creditCharge
     */
    public final int getCreditCharge() {
        return this.creditCharge;
    }

    @Override
    public void retainPayload() {
        this.retainPayload = true;
    }

        return Stream.of(
                Arguments.of("Unix", Configuration.unix(), "/"),
                Arguments.of("Windows", Configuration.windows(), "\\"));
    }

    @Override
    @BeforeEach
    public void setUp() throws Exception {
        projectBuilder = getContainer().lookup(ProjectBuilder.class);
    }

    protected MavenProject getProject(Artifact pom, boolean allowStub) throws Exception {

    class CtorValidation {
        @Test
        @DisplayName("null handle throws NPE")
        void nullHandle() {
            assertThrows(NullPointerException.class, () -> new SmbPipeInputStream(null, tree));
        }

        @Test
        @DisplayName("null tree throws NPE")
        void nullTree() {
            assertThrows(NullPointerException.class, () -> new SmbPipeInputStream(handle, null));
        }

@IgnoreJRERequirement // We opt into library desugaring for our tests.
public class MapComputeTester<K, V> extends AbstractMapTester<K, V> {
  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE})
  public void testCompute_absentToPresent() {
    assertEquals(
        "Map.compute(absent, functionReturningValue) should return value",
        v3(),
        getMap()
            .compute(
                k3(),

    }
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(ALLOWS_NULL_KEYS)
  public void testAsMapGetNullKeyPresent() {
    initMultimapWithNullKey();
    assertContentsAnyOrder(multimap().asMap().get(null), getValueForNullKey());
  }

  @MapFeature.Require(ALLOWS_NULL_KEY_QUERIES)
  public void testAsMapGetNullKeyAbsent() {
    assertNull(multimap().asMap().get(null));
  }

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class MapComputeTester<K, V> extends AbstractMapTester<K, V> {
  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE})
  public void testCompute_absentToPresent() {
    assertEquals(
        "Map.compute(absent, functionReturningValue) should return value",
        v3(),
        getMap()
            .compute(
                k3(),