assertEquals(5, aggressivePolicy.getMaxAttempts());
        assertEquals(500, aggressivePolicy.getInitialDelayMs());
        assertEquals(60000, aggressivePolicy.getMaxDelayMs());
        assertEquals(1.5, aggressivePolicy.getBackoffMultiplier());
        assertTrue(aggressivePolicy.isExponentialBackoff());

        // CONSERVATIVE policy

    settings1[Settings.HEADER_TABLE_SIZE] = 10000
    settings1[Settings.INITIAL_WINDOW_SIZE] = 20000
    settings1[Settings.MAX_FRAME_SIZE] = 30000
    peer.sendFrame().settings(settings1)
    peer.acceptFrame() // ACK SETTINGS
    val settings2 = Settings()
    settings2[Settings.INITIAL_WINDOW_SIZE] = 40000
    settings2[Settings.MAX_FRAME_SIZE] = 50000
    settings2[Settings.MAX_CONCURRENT_STREAMS] = 60000

    public void testConfigureKeyRotation() {
        // Test that configuration doesn't throw
        keyManager.configureKeyRotation(60000);

        // Test disabling rotation
        keyManager.configureKeyRotation(0);

        // Test reconfiguring
        keyManager.configureKeyRotation(30000);
    }

    @Test
    public void testConcurrentKeyOperations() throws InterruptedException {
        int threadCount = 10;

        Map<String, String> infoMap = new HashMap<>();
        infoMap.put(Constants.CRAWLER_STATUS, Constants.TRUE);
        infoMap.put("CrawlerStartTime", "2024-01-01T10:00:00");
        infoMap.put("CrawlerEndTime", "2024-01-01T11:00:00");

        try {
            crawler.sendMail(infoMap);
        } catch (Exception e) {
            fail("Should not throw exception: " + e.getMessage());
        }
    }

    );
    
    assertNotNull(registration.getRegistrationId());
    assertEquals(WitnessRegistrationState.REGISTERING, registration.getState());
    assertFalse(registration.isExpired(60000));
    
    // Test sequence numbers
    long seq1 = registration.getNextSequenceNumber();
    long seq2 = registration.getNextSequenceNumber();
    assertEquals(seq1 + 1, seq2);
}

@Test

    assertThat(client.callTimeoutMillis).isEqualTo(0)
    assertThat(client.connectTimeoutMillis).isEqualTo(10000)
    assertThat(client.readTimeoutMillis).isEqualTo(10000)
    assertThat(client.writeTimeoutMillis).isEqualTo(10000)
    assertThat(client.pingIntervalMillis).isEqualTo(0)
    assertThat(client.webSocketCloseTimeout).isEqualTo(60_000)
  }

  @Test fun webSocketDefaults() {
    val client = clientTestRule.newClient()

    void setUp() {
        mockContext = mock(CIFSContext.class);
        mockConfig = mock(Configuration.class);
        when(mockContext.getConfig()).thenReturn(mockConfig);
        when(mockConfig.getLeaseTimeout()).thenReturn(30000);
        when(mockConfig.getMaxLeases()).thenReturn(1000);
        when(mockConfig.getLeaseBreakTimeout()).thenReturn(60);
        leaseManager = new LeaseManager(mockContext);
    }

    @AfterEach

    out.writeBoolean(true);
    out.writeBoolean(false);
    out.writeByte(100);
    out.writeByte(-100);
    out.writeByte((byte) 200);
    out.writeChar('a');
    out.writeShort((short) -30000);
    out.writeShort((short) 50000);
    out.writeInt(0xCAFEBABE);
    out.writeLong(0xDEADBEEFCAFEBABEL);
    out.writeUTF("Herby Derby");
    out.writeFloat(Float.intBitsToFloat(0xCAFEBABE));

  }

  public void testAsMap_containsValue() {
    Cache<Integer, Integer> cache =
        CacheBuilder.newBuilder().expireAfterWrite(20000, MILLISECONDS).ticker(fakeTicker).build();

    cache.put(654, 2675);
    fakeTicker.advance(10000, MILLISECONDS);
    cache.put(2456, 56);
    cache.put(2, 15);

    fakeTicker.advance(10001, MILLISECONDS);

    assertTrue(cache.asMap().containsValue(15));

    }

    public void test_setCrawlerWaitMillis() {
        IntervalControlHelper helper = new IntervalControlHelper();

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

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

        helper.setCrawlerWaitMillis(0);