@Test
  fun writeAndReadEntry() {
    val creator = cache.edit("k1")!!
    creator.setString(0, "ABC")
    creator.setString(1, "DE")
    assertThat(creator.newSource(0)).isNull()
    assertThat(creator.newSource(1)).isNull()
    creator.commit()
    val snapshot = cache["k1"]!!
    snapshot.assertValue(0, "ABC")
    snapshot.assertValue(1, "DE")
  }

  @Test
  fun readAndWriteEntryAcrossCacheOpenAndClose() {

  fun successfulCallEventSequence() {
    server.enqueue(MockResponse(body = "abc"))
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    val response = call.execute()
    assertThat(response.code).isEqualTo(200)
    assertThat(response.body.string()).isEqualTo("abc")
    response.body.close()

	const keep = 10
	ss := &suffixSaver{keep: keep}
	ss.Write([]byte("abc"))
	if got := string(ss.Suffix()); got != "abc" {
		t.Errorf("got = %q; want abc", got)
	}
	ss.Write([]byte("defghijklmno"))
	if got := string(ss.Suffix()); got != "fghijklmno" {
		t.Errorf("got = %q; want fghijklmno", got)
	}
	if got, want := ss.Size(), int64(len("abc")+len("defghijklmno")); got != want {
		t.Errorf("Size = %d; want %d", got, want)

        final Map<String, Object> params = new HashMap<>();
        params.put(Constants.JOB_LOG_ID, "test-log-id-abc");
        scheduledJob.start(params);

        assertTrue(launchNowCalled.get());
        assertNotNull(capturedOption.get());
        assertEquals("test-log-id-abc", capturedOption.get().getParameterMap().get(Constants.JOB_LOG_ID));
    }

    @Test

        void unwrapDOSFilter_returnsInnerDosFileFilter_whenWrapped() throws Exception {
            // Arrange: create a ResourceFilterWrapper that wraps a DosFileFilter
            DosFileFilter dos = new DosFileFilter("abc", 7);
            Object wrapper = newPrivateInner("ResourceFilterWrapper", new Class<?>[] { SmbFileFilter.class }, dos);
            // unwrapDOSFilter is a private static method on SmbEnumerationUtil

import okio.Timeout
import okio.buffer
import org.junit.jupiter.api.Test

class IsProbablyUtf8Test {
  @Test fun isProbablyUtf8() {
    assertThat(Buffer().isProbablyUtf8(16L)).isTrue()
    assertThat(Buffer().writeUtf8("abc").isProbablyUtf8(16L)).isTrue()
    assertThat(Buffer().writeUtf8("new\r\nlines").isProbablyUtf8(16L)).isTrue()
    assertThat(Buffer().writeUtf8("white\t space").isProbablyUtf8(16L)).isTrue()

        "1-beta123",
        "1-m2",
        "1-m11",
        "1-rc",
        "1-cr2",
        "1-rc123",
        "1-SNAPSHOT",
        "1",
        "1-sp",
        "1-sp2",
        "1-sp123",
        "1-abc",
        "1-def",
        "1-pom-1",
        "1-1-snapshot",
        "1-1",
        "1-2",
        "1-123"
    };

    private static final String[] VERSIONS_NUMBER = {

 * @author Jens Nyman
 */
@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
public class FakeTimeLimiterTest extends TestCase {

  private static final int DELAY_MS = 50;
  private static final String RETURN_VALUE = "abc";

  private TimeLimiter timeLimiter;

  @Override
  protected void setUp() throws Exception {
    super.setUp();
    timeLimiter = new FakeTimeLimiter();
  }

		{"---", "", ObjectInfo{}, BucketNameInvalid{Bucket: "---"}, false},
		{"ad", "", ObjectInfo{}, BucketNameInvalid{Bucket: "ad"}, false},
		// Test cases with valid but non-existing bucket names (Test number 5-6).
		{"abcdefgh", "abc", ObjectInfo{}, BucketNotFound{Bucket: "abcdefgh"}, false},
		{"ijklmnop", "efg", ObjectInfo{}, BucketNotFound{Bucket: "ijklmnop"}, false},
		// Test cases with valid but non-existing bucket names and invalid object name (Test number 7-8).

			t.Errorf("Matcher Case %d failed", i)
		}
	}

	evalCases := []struct {
		iText, iPat   string
		iEsc          rune
		matchExpected bool
		errExpected   error
	}{
		{"abcd", "abc", runeZero, false, nil},
		{"abcd", "abcd", runeZero, true, nil},
		{"abcd", "abc_", runeZero, true, nil},
		{"abcd", "_bdd", runeZero, false, nil},
		{"abcd", "_b_d", runeZero, true, nil},