SmbConstants.DEFAULT_SHARING);

        // When & Then
        assertThrows(NullPointerException.class, () -> outputStream.write(null));
        assertThrows(NullPointerException.class, () -> outputStream.write(null, 0, 10));
    }

    @Test
    void testWriteInvalidOffsetAndLength() throws IOException, CIFSException {
        // Given

        assertThrows(SmbException.class, () -> {
            validator.validatePath("\\\\..\\share");
        });

        // Test invalid characters in paths - caught by null byte check
        assertThrows(SmbException.class, () -> {
            // Null byte will be caught
            validator.validatePath("//server\0/share");
        });

        // Test path with control characters in strict mode

        .build()
  }

  private fun newVirtualThreadPerTaskExecutor(): ExecutorService =
    Executors::class.java.getMethod("newVirtualThreadPerTaskExecutor").invoke(null) as ExecutorService

  @Test
  fun testRequest() {
    server.enqueue(MockResponse())

    val request = Request(server.url("/"))

    client.newCall(request).execute().use {

    this.singleKey = key;
    this.singleValue = value;
    this.inverse = inverse;
  }

  @Override
  public ImmutableBiMap<V, K> inverse() {
    ImmutableBiMap<V, K> result = inverse;
    if (result == null) {
      return inverse = new SingletonImmutableBiMap<V, K>(singleValue, singleKey, this);
    } else {
      return result;
    }
  }

  @Override
  public ImmutableSet<V> values() {

    return value;
  }

  final @Nullable Listener listeners() {
    return listeners;
  }

  final void releaseWaiters() {}

  AbstractFutureState() {}

  static final Object NULL = new Object();

  static final LazyLogger log = new LazyLogger(AbstractFuture.class);

  static final boolean GENERATE_CANCELLATION_CAUSES = false;

  private volatile @Nullable Object value;

            throw new IOException("unexpected EOF reading netbios retarget session response");
        }
        final int addr = readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        new NbtAddress(null, addr, false, NbtAddress.B_NODE);
        readInt2(buffer, bufferIndex);
        return this.length;
    }

        assertThat(out.getNotify(), is("closed"));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testCloseNull() throws Exception {
        CloseableUtil.close((OutputStream) null);
    }

    /**
     * @throws Exception
     */
    @Test
    public void testClose_noThrowIOException() throws Exception {
        final OutputStream out = new IOExceptionOccurOutputStream();

public class ClassLoaderIteratorTest {

    /**
     * @throws Exception
     */
    @Test
    public void test() throws Exception {
        final ClassLoader cl1 = new URLClassLoader(new URL[] { new URL("file:/foo") }, null);
        final ClassLoader cl2 = new URLClassLoader(new URL[] { new URL("file:/bar") }, cl1);
        final ClassLoader cl3 = new URLClassLoader(new URL[] { new URL("file:/baz") }, cl2);

    /**
     * Unwrap credentials to a specific type.
     *
     * @param <T> the credential type to unwrap to
     * @param type the class of the credential type to unwrap to
     * @return instance for type, null if the type cannot be unwrapped
     */
    <T extends Credentials> T unwrap(Class<T> type);

    /**
     * Get the domain of the user account.
     * @return the domain the user account is in
     */

        charMappingFile.manager(dictionaryManager);
    }

    @Override
    public void tearDown() throws Exception {
        if (testFile != null && testFile.exists()) {
            testFile.delete();
        }
        super.tearDown();
    }

    // Test getType method
    public void test_getType() {