)
      }

      request.isChunked -> {
        newChunkedSink()
      }

      // Stream a request body of unknown length.
      contentLength != -1L -> {
        newKnownLengthSink()
      }

      // Stream a request body of a known length.
      else -> {
        // Stream a request body of a known length.
        throw IllegalStateException(

            assertNotNull(lock);
        }

        @Test
        @DisplayName("Should create lock with negative values")
        void testConstructorWithNegativeValues() {
            lock = new Smb2Lock(-1L, -1L, -1);

            assertNotNull(lock);
        }
    }

    @Nested
    @DisplayName("Size Tests")
    class SizeTests {

        @Test
        @DisplayName("Should return constant size of 24 bytes")

   */
  public void assertSuccess(Object expectedData) throws Throwable {
    // Verify that the listener executed in a reasonable amount of time.
    Assert.assertTrue(countDownLatch.await(1L, SECONDS));

    try {
      Assert.assertEquals(expectedData, future.get());
    } catch (ExecutionException e) {
      throw e.getCause();
    }
  }

  /**

        DataStoreParams params = new DataStoreParams();
        Map<String, Object> data = new HashMap<>();
        data.put("key1", "value1");
        callback.store(params, data);

        assertEquals(1L, callback.getDocumentSize());
        assertEquals(100L, callback.getExecuteTime());

        // Test multiple stores
        callback.store(params, data);
        callback.store(params, data);

     */
    @Test
    public void test_sleep() throws Exception {
        ThreadUtil.sleep(1L);
        assertTrue(true);
        ThreadUtil.sleepQuietly(1L);
    }

    /**
     * @throws Exception
     */
    @Test
    public void test_sleepQuietly() throws Exception {
        ThreadUtil.sleepQuietly(1L);
        assertTrue(true);
    }

   *     take any event class.
   * @param elapsedMs the time in milliseconds elapsed since the immediately-preceding event, or
   *     -1L to take any duration.
   */
  fun takeEvent(
    eventClass: Class<out CallEvent>? = null,
    elapsedMs: Long = -1L,
  ): CallEvent {
    val result = eventSequence.remove()
    val actualElapsedNs = result.timestampNs - (lastTimestampNs ?: result.timestampNs)

                CollectSpliterators.flatMapToLong(
                    Arrays.spliterator(new Long[] {1L, 0L, 1L, 2L, 3L}),
                    (Long i) -> i == 0L ? null : LongStream.of(i).spliterator(),
                    Spliterator.SIZED | Spliterator.DISTINCT | Spliterator.NONNULL,
                    4))
        .expect(1L, 1L, 2L, 3L);
  }

  public void testFlatMapToDouble_nullStream() {
    SpliteratorTester.ofDouble(

        assertEquals("https://discuss.codelibs.org/c/FessEN/", systemHelper.getForumLink());
        ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {
            private static final long serialVersionUID = 1L;

            @Override
            public String getForumLink() {
                return StringUtil.EMPTY;
            }
        });
        getMockRequest().setLocale(Locale.ENGLISH);

import com.google.common.cache.CacheBuilder;

public class FessConfigImpl extends FessConfig.SimpleImpl {

    private static final long serialVersionUID = 1L;

    private static class KeyNotFoundException extends Exception {
        private static final long serialVersionUID = 1L;

        private KeyNotFoundException(final String key) {
            super(key);
        }
    }

    @Override

     */
    @Test
    public void testWriteBytesWireFormat() {
        // Given
        SmbComClose smbComClose = new SmbComClose(config, 1, 1L);
        byte[] dst = new byte[0];

        // When
        int bytesWritten = smbComClose.writeBytesWireFormat(dst, 0);

        // Then
        assertEquals(0, bytesWritten);
    }

    /**