assertEquals(2, bytesWritten, "Should write 2 bytes.");
        assertEquals(SmbComTransaction.TRANS2_QUERY_PATH_INFORMATION, dst[0], "The first byte should be the subCommand.");
        assertEquals((byte) 0x00, dst[1], "The second byte should be 0.");
    }

    /**
     * Tests the writeParametersWireFormat method.
     */
    @Test
    void testWriteParametersWireFormat() {
        // Given

                    } finally {
                        latch.countDown();
                    }
                }).start();
            }

            latch.await(5, java.util.concurrent.TimeUnit.SECONDS);
            assertEquals(5, successCount.get(), "All concurrent calls should succeed");
        }
    }

        assertEquals(4, written, "Setup should write 4 bytes");
        assertEquals(SmbComTransaction.TRANS_WAIT_NAMED_PIPE, dst[0], "First byte should be subCommand");
        assertEquals(0, dst[1], "Second byte should be 0");
        assertEquals(0, dst[2], "Third byte should be 0 (no FID)");
        assertEquals(0, dst[3], "Fourth byte should be 0 (no FID)");
    }

    @Test
    public void testReadSetupWireFormat() {

            // Get local midnight boundary
            Calendar cal = Calendar.getInstance();

            cal.set(Calendar.HOUR_OF_DAY, 0);
            cal.set(Calendar.MINUTE, 0);
            cal.set(Calendar.SECOND, 0);
            cal.set(Calendar.MILLISECOND, 0);

            if (cal.getTime().after(lastModified)) {
                checkForUpdates = true;
            }

func (r BatchJobExpire) Notify(ctx context.Context, body io.Reader) error {
	if r.NotificationCfg.Endpoint == "" {
		return nil
	}

	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, r.NotificationCfg.Endpoint, body)
	if err != nil {
		return err
	}

	if r.NotificationCfg.Token != "" {

        assertEquals("Second group should be AnotherTestGroup", AnotherTestGroup.class, multiAnnotation.groups()[1]);

        assertEquals("Should have 2 payloads", 2, multiAnnotation.payload().length);
        assertEquals("First payload should be TestPayload", TestPayload.class, multiAnnotation.payload()[0]);

        request = new Smb2CreateRequest(mockConfig, "initial\\path.txt");
        assertEquals("\\initial\\path.txt", request.getPath());

        request.setPath("\\second\\path.txt");
        assertEquals("\\second\\path.txt", request.getPath());

        request.setPath("third\\path\\");
        assertEquals("\\third\\path", request.getPath());

        }

        @Test
        @DisplayName("Binary constructor with invalid sub_authority_count throws RuntimeCIFSException")
        void testBinaryConstructorInvalidCount() {
            // Arrange: second byte is sub_authority_count > 100
            byte[] bytes = new byte[1 + 1 + 6];
            bytes[0] = 1; // revision
            bytes[1] = (byte) 101; // invalid count

            // Act + Assert

		t.Errorf("Expected key1 to exist, but it was evicted")
	}
}

func TestLRU_Add_Eviction(t *testing.T) {
	lru := lru.NewLRU[string, int](0, nil, time.Second*2)
	lru.Add("key1", 1)
	lru.Add("key2", 2)
	lru.Add("key3", 3)
	time.Sleep(time.Second * 3)
	if lru.Cap() != 0 {
		t.Errorf("Expected lru to be empty, but it was not")
	}

}

func BenchmarkLRU_Rand_NoExpire(b *testing.B) {

    assertThat(Adapters.parseGeneralizedTime("19920622123421Z"))
      .isEqualTo(date("1992-06-22T12:34:21.000+0000").time)
  }

  @Disabled("fractional seconds are not implemented")
  @Test
  fun `parse generalized time with fractional seconds`() {
    assertThat(Adapters.parseGeneralizedTime("19920722132100.3Z"))
      .isEqualTo(date("1992-07-22T13:21:00.300+0000").time)
  }