}

    /**
     * Initializes the service.
     */
    @PostConstruct
    public void init() {
        fesenClient.addOnConnectListener(() -> createMapping("queue"));
    }

    /**
     * Destroys the service.
     */
    @PreDestroy
    public void destroy() {
        sessionCache.entrySet().stream().map(e -> e.getValue().waitingQueue).forEach(q -> q.forEach(urlQueue -> {

        void testGetLastWriteTime() {
            assertEquals(0, response.getLastWriteTime());
        }

        @Test
        @DisplayName("getChangeTime should return initial value of 0")
        void testGetChangeTime() {
            assertEquals(0, response.getChangeTime());
        }

        @Test
        @DisplayName("getAllocationSize should return initial value of 0")
        void testGetAllocationSize() {

    multimap.put("foo", 1);
    assertEquals("{foo=[3, -1, 2, 4, 1], bar=[1, 2, 3]}", multimap.toString());
  }

  public void testOrderingReadOnly() {
    SetMultimap<String, Integer> multimap = initializeMultimap5();
    assertOrderingReadOnly(multimap);
  }

  public void testOrderingUnmodifiable() {
    SetMultimap<String, Integer> multimap = initializeMultimap5();

        @Test
        void setup() {
            assertEquals(0, cmd.readSetupWireFormat(new byte[10], 0, 0));
        }

        @Test
        void parameters() {
            assertEquals(0, cmd.readParametersWireFormat(new byte[10], 0, 0));
        }

        @Test
        void data() {
            assertEquals(0, cmd.readDataWireFormat(new byte[10], 0, 0));

class ByteEncodableTest {

    @Test
    void testConstructorAndSize() {
        // Test with a basic byte array
        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05 };
        ByteEncodable encodable = new ByteEncodable(data, 1, 3);

        // Verify size
        assertEquals(3, encodable.size(), "Size should be equal to the specified length");
    }

    @Test
    void testEncodeBasic() {
        // Test basic encoding

  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_KEYS})
  public void testComputeIfAbsent_nullKeySupported() {
    getMap()
        .computeIfAbsent(
            null,
            k -> {
              assertNull(k);
              return v3();
            });
    expectAdded(entry(null, v3()));
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testComputeIfAbsent_functionThrows() {
    assertThrows(

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutIfAbsent_supportedAbsent() {
    assertNull(
        "putIfAbsent(notPresent, value) should return null", getMap().putIfAbsent(k3(), v3()));
    expectAdded(e3());
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testPutIfAbsent_supportedPresent() {
    assertEquals(

          break;
        case EXCEPTION_DATA:
          throw EXCEPTION;
      }
      return outputFuture;
    }
  }

  public void testFutureGetThrowsFunctionException() throws Exception {
    inputFuture.set(EXCEPTION_DATA);
    listener.assertException(EXCEPTION);
  }

  public void testFutureGetThrowsCancellationIfInputCancelled() throws Exception {
    inputFuture.cancel(true); // argument is ignored

          break;
        case EXCEPTION_DATA:
          throw EXCEPTION;
      }
      return outputFuture;
    }
  }

  public void testFutureGetThrowsFunctionException() throws Exception {
    inputFuture.set(EXCEPTION_DATA);
    listener.assertException(EXCEPTION);
  }

  public void testFutureGetThrowsCancellationIfInputCancelled() throws Exception {
    inputFuture.cancel(true); // argument is ignored

    private long testSessionId;

    @BeforeEach
    void setUp() {
        transformHeader = new Smb2TransformHeader();
        testNonce = new byte[16];
        new SecureRandom().nextBytes(testNonce);
        testSessionId = 0x123456789ABCDEF0L;
    }

    @Test
    @DisplayName("Should create transform header with correct size")
    void testTransformHeaderSize() {
        // When