return;
                case 2:
                    throw new IllegalArgumentException("Invalid argument");
                case 3:
                    throw new IllegalStateException("Invalid state");
                case 4:
                    throw new NullPointerException("Null pointer");
                default:
                    throw new RuntimeException("Generic error");
                }
            }

  public void testFlush_flushableWithEatenException() throws IOException {
    // make sure that no exception is thrown if 'swallowException' is true
    // when the mock does throw an exception on flush.
    setupFlushable(true);
    doFlush(mockFlushable, true, false);
  }

  public void testFlush_flushableWithThrownException() throws IOException {
    // make sure that the exception is thrown if 'swallowException' is false

                        throw new UnsupportedOperationException();
                      }

                      @Override
                      public Iterator<String> iterator() {
                        throw new UnsupportedOperationException();
                      }

                      @Override
                      public boolean removeAll(Collection<?> collection) {

     * @param argValue
     *            The value of the argument.
     * @throws NullArgumentException
     *             If the argument is <code>null</code>.
     */
    public static void assertArgumentNotNull(final String argName, final Object argValue) {
        if (argValue == null) {
            throw new NullArgumentException(argName);
        }
    }

    /**

            state = RdmaConnectionState.ERROR;
            throw new IOException("TCP RDMA connection failed", e);
        }
    }

    @Override
    public void send(ByteBuffer data, RdmaMemoryRegion region) throws IOException {
        if (state != RdmaConnectionState.ESTABLISHED && state != RdmaConnectionState.CONNECTED) {
            throw new IOException("Connection not established");
        }

        try {

                try {
                    customCb.executeWithCircuitBreaker(() -> {
                        throw new RuntimeException("non-critical error");
                    }, isFailure);
                    fail("Should have thrown exception");
                } catch (CIFSException e) {
                    // Expected - exception is thrown but not counted as failure
                }
            }

                    throw new SmbUnsupportedOperationException();
                }
                throw e;
            }
            try (SmbFile browser = (SmbFile) parent.resolve(addr.getHostAddress())) {
                try (SmbTreeHandleImpl th = browser.ensureTreeConnected()) {
                    if (th.isSMB2()) {
                        throw new SmbUnsupportedOperationException();

            nameServiceClient.getByName(null);
        }, "Should throw UnknownHostException for null hostname");
    }

    @Test
    @DisplayName("Should handle empty hostname in getByName")
    void testGetByNameWithEmpty() {
        // When/Then
        assertThrows(UnknownHostException.class, () -> {
            nameServiceClient.getByName("");
        }, "Should throw UnknownHostException for empty hostname");
    }

    @Override
    @Deprecated
    public void connectLogon(final CIFSContext tf) throws SmbException {
        if (tf.getConfig().getLogonShare() == null) {
            try {
                treeConnect(null, null);
            } catch (final SmbException e) {
                throw e;
            } catch (final CIFSException e) {
                throw SmbException.wrap(e);
            }
        } else {

          public Integer computeNext() {
            if (haveBeenCalled) {
              throw new AssertionError("Should not have been called again");
            } else {
              haveBeenCalled = true;
              throw sneakyThrow(new SomeCheckedException());
            }
          }
        };

    // The first time, the sneakily-thrown exception comes out
    assertThrows(SomeCheckedException.class, iter::hasNext);