}

    @Test
    public void test_throwAndCatch() {
        // Test that the exception can be thrown and caught properly
        ServletException originalException = new ServletException("Throw test");

        try {
            throw new ServletRuntimeException(originalException);
        } catch (ServletRuntimeException caught) {
            // Verify the caught exception

    return new URLClassLoader(ClassPathUtil.getClassPathUrls(), classLoader) {
      @Override
      public Class<?> loadClass(String name) throws ClassNotFoundException {
        if (disallowedClassNames.contains(name)) {
          throw new ClassNotFoundException("I'm sorry Dave, I'm afraid I can't do that.");
        }
        if (name.startsWith(concurrentPackage)) {

                throw new RuntimeException(e);
            }
        }, "close() should not throw any exception");
    }

    @Test
    @DisplayName("remove should not throw any exception")
    void testRemoveDoesNotThrowException() {
        // When & Then
        assertDoesNotThrow(() -> {
            emptyIterator.remove();
        }, "remove() should not throw any exception");
    }

    @Test

    @Override
    protected void setUp(TestInfo testInfo) throws Exception {
        super.setUp(testInfo);
        ComponentUtil.register(new SystemHelper(), "systemHelper");
    }

    @Test
    public void test_parse() throws IOException {
        GsaConfigParser parser = new GsaConfigParser();

            @Override
            public int read(char[] cbuf, int off, int len) throws IOException {
                if (delegate == null) {
                    delegate = transform(original);
                }
                return delegate.read(cbuf, off, len);
            }

            @Override
            public void close() throws IOException {
                if (delegate != null) {
                    delegate.close();

   * converted, an unchecked exception (such as {@link IllegalArgumentException}) should be thrown.
   *
   * @param b the instance to convert; will never be null
   * @return the converted instance; <b>must not</b> be null
   * @throws UnsupportedOperationException if backward conversion is not implemented; this should be

    }

    @Override
    public byte[] getName() {
        return CONTEXT_NAME_BYTES;
    }

    @Override
    public int decode(byte[] buffer, int bufferIndex, int len) throws SMBProtocolDecodingException {
        if (len != 8) {
            throw new SMBProtocolDecodingException("Invalid durable handle response length: " + len);
        }

        // Read reserved field (should be all zeros but we don't validate)

        return 0;
    }

    @Override
    int readTrailerWireFormat(final InputStream in, final byte[] buffer, int bufferIndex) throws IOException {
        if (in.read(buffer, bufferIndex, length) != length) {
            throw new IOException("unexpected EOF reading netbios retarget session response");
        }
        final int addr = readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        assertDoesNotThrow(() -> cache.resolveSids(handle, policy, sids));
    }

    @Test
    @DisplayName("resolveSids(DcerpcHandle,...) throws SmbException on unexpected retval")
    void resolveSids_throwsOnUnexpectedRetval() throws Exception {
        SIDCacheImpl cache = new SIDCacheImpl(mock(CIFSContext.class));
        DcerpcHandle handle = mock(DcerpcHandle.class);

  @BeforeEach
  fun setUp() {
    platform.assumeNotOpenJSSE()
    platform.assumeHttp2Support()
  }

  @Test
  fun serverTruncatesRequestOnLongPostHttp1() {
    // "java.net.SocketException: Socket closed" thrown reading response after
    // "java.net.SocketException: Connection reset by peer" writing request
    assumeNotWindows()

    serverTruncatesRequestOnLongPost(https = false)
  }

  @Test