ListeningScheduledExecutorService service = listeningDecorator(delegate);
    RuntimeException ex = new RuntimeException();
    ListenableFuture<?> future = service.schedule(new ThrowingRunnable(0, ex), 1, MILLISECONDS);
    assertExecutionException(future, ex);
    assertEquals(0, delegate.getQueue().size());
  }

  public void testListeningDecorator_schedulePeriodic() throws Exception {

        SpnegoContext ctx = newContext();

        // Invalid first byte should be rejected by token parsing
        CIFSException ex = assertThrows(CIFSException.class, () -> ctx.initSecContext(new byte[] { firstByte }, 0, 1));
        assertEquals("Invalid token", ex.getMessage());

        // Ensure mechContext was not engaged due to early failure

    f.set("foo");
  }

  public void testExecutorSuccess() {
    CountingSameThreadExecutor ex = new CountingSameThreadExecutor();
    SettableFuture<String> f = SettableFuture.create();
    MockCallback callback = new MockCallback("foo");
    Futures.addCallback(f, callback, ex);
    f.set("foo");
    assertEquals(1, ex.runCount);
  }

  // Error cases
  public void testSameThreadExecutionException() {

                initializeMultiChannel();

                // Initialize witness support for fast failover
                initializeWitnessSupport();

                if (ex != null) {
                    throw ex;
                }
                return (T) (response != null ? response.getNextResponse() : null);
            }
        }
    }

        CIFSException boom = new CIFSException("tree-fail");
        when(handle.ensureTreeConnected()).thenThrow(boom);

        // Act + Assert
        CIFSException ex = assertThrows(CIFSException.class, out::ensureTreeConnected);
        assertEquals("tree-fail", ex.getMessage());
        verify(handle, times(1)).ensureTreeConnected();
    }

    @Test
    @DisplayName("ensureOpen delegates and returns the file handle")

        doThrow(new CIFSException("Close failed")).when(delegate).close();

        TestIterator iterator = new TestIterator(null);

        CIFSException ex = assertThrows(CIFSException.class, iterator::close);
        assertEquals("Close failed", ex.getMessage());
    }

    @Test
    @DisplayName("Remove delegates to underlying iterator")
    void removeDelegation() {

        byte[] data = new byte[] { 0 };
        when(gssContext.getMIC(any(), anyInt(), anyInt(), any())).thenThrow(new GSSException(GSSException.FAILURE));

        CIFSException ex = assertThrows(CIFSException.class, () -> ctx.calculateMIC(data));
        assertTrue(ex.getMessage().contains("Failed to calculate MIC"));
    }

    @Test
    @DisplayName("calculateMIC with null data throws NPE")
    void calculateMIC_nullData() {

                        } catch (final Exception ex) {}
                        if (handlerClass == null) {
                            handlerClass = ClassLoader.getSystemClassLoader().loadClass(className);
                        }
                        handler = (URLStreamHandler) handlerClass.newInstance();
                        break;
                    } catch (final Exception ex) {}
                }
            }

                writeSecurityBuffer(type1, 24, 32 + domain.length, workstation);
            }
            return type1;
        } catch (final IOException ex) {
            throw new IllegalStateException(ex.getMessage());
        }
    }

    @Override
    public String toString() {
        final String suppliedDomain = getSuppliedDomain();

    RuntimeException re = new RuntimeException(iae);
    IllegalStateException ex = new IllegalStateException(re);

    assertThat(getCausalChain(ex)).containsExactly(ex, re, iae, sue).inOrder();
    assertSame(sue, Iterables.getOnlyElement(getCausalChain(sue)));

    List<Throwable> causes = getCausalChain(ex);
    assertThrows(UnsupportedOperationException.class, () -> causes.add(new RuntimeException()));
  }