// Test default wait time
        assertEquals(10000, helper.crawlerWaitMillis);

        // Test setting new wait time
        helper.setCrawlerWaitMillis(5000);
        assertEquals(5000, helper.crawlerWaitMillis);

        helper.setCrawlerWaitMillis(0);
        assertEquals(0, helper.crawlerWaitMillis);
    }

    @Test
    public void test_parseTime_validFormat() {

			Name:     "small.txt",
			Mode:     0640,
			Uid:      73025,
			Gid:      5000,
			Size:     5,
			ModTime:  time.Unix(1244428340, 0),
			Typeflag: '0',
			Uname:    "dsymonds",
			Gname:    "eng",
			Format:   FormatGNU,
		}, {
			Name:     "small2.txt",
			Mode:     0640,
			Uid:      73025,
			Gid:      5000,
			Size:     11,
			ModTime:  time.Unix(1244436044, 0),
			Typeflag: '0',

    assertThat(formatDuration(        -1_000L)).isEqualTo(" -1 µs")
    assertThat(formatDuration(          -999L)).isEqualTo(" -1 µs")
    assertThat(formatDuration(          -500L)).isEqualTo(" -1 µs")
    assertThat(formatDuration(          -499L)).isEqualTo("  0 µs")

    assertThat(formatDuration( 3_499_999_999L)).isEqualTo("  3 s ")
    assertThat(formatDuration( 3_000_000_000L)).isEqualTo("  3 s ")

    }

    @Test
    void mergeWithSameSnapshotWithDifferentVersionsAndNewerLastUpdated() {
        Metadata source = createMetadataFromArtifact(artifact);
        Date before = new Date(System.currentTimeMillis() - 5000);
        Date after = new Date(System.currentTimeMillis());
        addSnapshotVersion(target.getVersioning(), "jar", before, "1", 1);
        SnapshotVersion sv2 =

        assertEquals((byte) 0x00, getFieldValue(netServerEnum2, "maxSetupCount"));
        assertEquals(0, getFieldValue(netServerEnum2, "setupCount"));
        assertEquals(5000, getFieldValue(netServerEnum2, "timeout"));
    }

    @Test
    @DisplayName("Test constructor with empty domain")
    void testConstructorEmptyDomain() {
        String domain = "";

		wantInverted: []sparseEntry{{0, 0}},
	}, {
		in: []sparseEntry{}, size: 5000,
		wantValid:    true,
		wantInverted: []sparseEntry{{0, 5000}},
	}, {
		in: []sparseEntry{{0, 5000}}, size: 5000,
		wantValid:    true,
		wantAligned:  []sparseEntry{{0, 5000}},
		wantInverted: []sparseEntry{{5000, 0}},
	}, {
		in: []sparseEntry{{1000, 4000}}, size: 5000,
		wantValid:    true,
		wantAligned:  []sparseEntry{{1024, 3976}},

            buffer.putLong(1000L);
            buffer.putLong(500L);
            buffer.putInt(1);
            buffer.putInt(sectorSize);

            // When
            fileFsSizeInfo.decode(buffer.array(), 0, 24);

            // Then
            assertEquals(1000L * sectorSize, fileFsSizeInfo.getCapacity());
            assertEquals(500L * sectorSize, fileFsSizeInfo.getFree());
        }

        @Test

```

### Lambda Target with mTLS authentication

If your lambda target expects mTLS client you can enable it per function target as follows
```

    }
  }

  @Test fun closeReservedThrows() {
    assertFailsWith<IllegalArgumentException> {
      clientWriter.writeClose(1005, "Hello".encodeUtf8())
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Code 1005 is reserved and may not be used.")
    }
  }

  @Test fun serverEmptyPing() {
    serverWriter.writePing(EMPTY)
    assertData("8900")
  }

            });
            readThreads[i].start();
        }

        // Wait for all threads
        for (Thread thread : updateThreads) {
            thread.join(5000);
        }
        for (Thread thread : readThreads) {
            thread.join(5000);
        }

        // Verify final state
        assertEquals(100, entry.getChildren().size());
        assertTrue(entry.hasChanges());
    }