assertEquals(Service.State.FAILED, service.state());
  }

  public void testFunctionalStop_failed() {
    Exception exception = new Exception("deliberate");
    AbstractIdleService service =
        new DefaultService() {
          @Override
          protected void shutDown() throws Exception {
            throw exception;
          }
        };
    service.startAsync().awaitRunning();

@NullUnmarked
public class SingleThreadAbstractFutureBenchmark {
  @Param Impl impl;

  private final Exception exception = new Exception();
  private Facade<?> notDoneFuture;

  @BeforeExperiment
  void setUp() throws Exception {
    notDoneFuture = impl.newFacade();
  }

  @Benchmark
  public long timeComplete_Normal(int reps) throws Exception {
    long r = 0;
    List<Facade<Integer>> list = new ArrayList<>(reps);

    }

    @Test
    public void testReleaseSendRegion() throws Exception {
        RdmaMemoryRegion region = bufferManager.getSendRegion(1024);
        assertNotNull(region);

        // Release should not throw exception
        assertDoesNotThrow(() -> bufferManager.releaseSendRegion(region));
    }

    @Test
    public void testGetReceiveRegion() throws Exception {
        RdmaMemoryRegion region = bufferManager.getReceiveRegion();

        void testNullConfigurationThrowsException() throws Exception {
            // Given
            Constructor<SmbComNtCancel> constructor = SmbComNtCancel.class.getDeclaredConstructor(Configuration.class, int.class);
            constructor.setAccessible(true);

            // When & Then
            InvocationTargetException exception = assertThrows(InvocationTargetException.class, () -> constructor.newInstance(null, 1));

            der.close();
        }
        return collector.toByteArray();
    }

    @Test
    @DisplayName("Round-trip: all fields set encodes and parses back correctly")
    void testRoundTripAllFields() throws Exception {
        ASN1ObjectIdentifier[] mechs = new ASN1ObjectIdentifier[] { OID_KRB, OID_NTLM };
        int flags = NegTokenInit.DELEGATION | NegTokenInit.MUTUAL_AUTHENTICATION | NegTokenInit.INTEGRITY;

    /**
     * @throws Exception
     */
    @Test
    public void testFileToFile() throws Exception {
        final byte[] bytes = readBytes(inputFile);
        assertThat(bytes, is("あいうえお".getBytes("UTF-8")));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testReadUTF8() throws Exception {

    }

    @Test
    @DisplayName("Test decode throws exception with zero length")
    void testDecodeThrowsExceptionWithZeroLength() {
        byte[] buffer = new byte[28];

        SMBProtocolDecodingException exception = assertThrows(SMBProtocolDecodingException.class, () -> response.decode(buffer, 0, 0),
                "Should throw exception when length is 0");

            exception = t;
          } else {
            exception.addSuppressed(t);
          }
        }
      }
    }
    if (exception != null) {
      throwIfUnchecked(exception);
      throw new RuntimeException("failure during tearDown", exception);
    }
  }

            exception = t;
          } else {
            exception.addSuppressed(t);
          }
        }
      }
    }
    if (exception != null) {
      throwIfUnchecked(exception);
      throw new RuntimeException("failure during tearDown", exception);
    }
  }

        return severity;
    }

    public Version getVersion() {
        return version;
    }

    public Exception getException() {
        return exception;
    }

    public ModelProblemCollectorRequest setException(Exception exception) {
        this.exception = exception;
        return this;
    }

    public String getMessage() {
        return message;
    }