@Override
      public void write(int c) throws IOException {
        separatingAppendable.append((char) c);
      }

      @Override
      public void write(char[] chars, int off, int len) throws IOException {
        throw new UnsupportedOperationException();
      }

      @Override
      public void flush() throws IOException {
        delegate.flush();
      }

      @Override

      override fun fromDer(reader: DerReader): Pair<DerAdapter<*>, Any?> {
        val peekedHeader =
          reader.peekHeader()
            ?: throw ProtocolException("expected a value at $reader")

        val choice =
          choices.firstOrNull { it.matches(peekedHeader) }
            ?: throw ProtocolException(
              "expected a matching choice but was $peekedHeader at $reader",
            )

              @Override
              public Collection<String> create(String[] elements) {
                // TODO: MinimalCollection should perhaps throw
                for (Object element : elements) {
                  if (element == null) {
                    throw new NullPointerException();
                  }
                }
                return MinimalCollection.of(elements);
              }
            })

            throw new InvalidQueryRegisteredException(msg);
        }
    }

    protected void checkEsInvalidAggregationCollection(String name, Collection<?> values) {
        if (values == null || values.isEmpty()) {
            String msg = "Cannot register null or empty query collection: name=" + name + " values=" + values;
            throw new InvalidQueryRegisteredException(msg);
        }

      startUpCalled = true;
      throw new UnsupportedOperationException("kaboom!");
    }

    @Override
    protected void run() {
      throw new AssertionError("run() should not be called");
    }

    @Override
    protected Executor executor() {
      return exceptionCatchingExecutor;
    }
  }

  public void testServiceThrowOnRun() throws Exception {

            // Should either throw exception or fail gracefully after close
            try {
                digest.sign(data, 0, data.length, request, response);
                // If no exception is thrown, the operation should have been no-op or handled gracefully
                assertTrue(true, "Sign operation after close should either throw exception or handle gracefully");

         *
         * @return Never returns, always throws UnsupportedOperationException
         * @throws UnsupportedOperationException Always thrown as this operation is not supported
         */
        @Override
        public ServletContext getServletContext() {
            throw new UnsupportedOperationException("getServletContext() is not supported in SpnegoFilterConfig");
        }

        void testSendFragment() throws IOException {
            // When: Calling send fragment (no-op implementation)
            // Then: Should not throw exception
            assertDoesNotThrow(() -> handle.doSendFragment(new byte[10], 0, 10));
        }

        @Test
        @DisplayName("Should handle encode message operation")
        void testEncodeMessage() throws NdrException, DcerpcException {

        } catch (XMLStreamException e) {
            throw new SettingsParseException(
                    e.getMessage(),
                    e.getLocation().getLineNumber(),
                    e.getLocation().getColumnNumber(),
                    e);
        }
    }

    @Override
    public Settings read(Reader input, Map<String, ?> options) throws IOException {

        try {
            server.start();
        } catch (final Exception e) {
            throw new CrawlerSystemException(e);
        }
    }

    public void stop() {
        try {
            server.stop();
            server.join();
        } catch (final Exception e) {
            throw new CrawlerSystemException(e);
        } finally {
            if (tempDocRoot) {
                docRoot.delete();