* 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

   * the service will transition to the {@link Service.State#FAILED} state and this method will no
   * longer be called.
   */
  protected abstract void runOneIteration() throws Exception;

  /**
   * Start the service.
   *
   * <p>By default this method does nothing.
   */
  protected void startUp() throws Exception {}

  /**

        void testGetTransportContext() throws Exception {
            DcerpcPipeHandle handle = createMockedDcerpcPipeHandle();
            assertEquals(mockContext, handle.getTransportContext());
        }

        @Test
        @DisplayName("Should return correct server name")
        void testGetServer() throws Exception {
            DcerpcPipeHandle handle = createMockedDcerpcPipeHandle();

      assertThat(expected).hasMessageThat().contains("[null]");
      foundProblem = true;
    }
    assertTrue("Should report error when different exception is thrown", foundProblem);
  }

  public void testMessageNoException() throws Exception {
    Method method = OneArg.class.getMethod("staticOneArgShouldThrowNpeButDoesnt", String.class);
    boolean foundProblem = false;
    try {

   * {@code IllegalArgumentException} is thrown, and otherwise the existing {@link Entry} is
   * returned.
   *
   * @throws IllegalArgumentException if another entry in the bucket has the same key and {@code
   *     throwIfDuplicateKeys} is true
   * @throws BucketOverflowException if this bucket has too many entries, which may indicate a hash
   *     flooding attack

        // Test execute method with negative boost - should throw exception
        QueryContext context = new QueryContext("*:*", false);
        MatchAllDocsQuery query = new MatchAllDocsQuery();
        float boost = -1.0f;

        try {
            matchAllQueryCommand.execute(context, query, boost);
            fail("Should throw IllegalArgumentException for negative boost");

            throws ModelBuilderException {
        ModelBuilderResult result = buildModel(session, src);
        Model model = result.getRawModel();
        return transformPom(model, project);
    }

    protected Model buildBomWithoutFlatten(RepositorySystemSession session, MavenProject project, ModelSource src)
            throws ModelBuilderException {

  }

  /**
   * @return the number of exceptions that were suppressed on the expected thrown exception
   */
  private static int runSuppressionFailureTest(ByteSource in, ByteSink out) {
    try {
      in.copyTo(out);
      fail();
    } catch (IOException expected) {
      return expected.getSuppressed().length;
    }
    throw new AssertionError(); // can't happen
  }

   * function that also supports reverse conversion.
   *
   * <p>If you are okay with {@code null} being returned for an unrecognized key (instead of an
   * exception being thrown), you can use the method reference {@code map::get} instead. Note that
   * it is not serializable unless you explicitly make it {@link Serializable}, typically by writing
   * {@code (Function<K, V> & Serializable) map::get}.

                        @Override
                        public InputStream getContentAsStream() throws IOException {
                            return new FileInputStream(testFile);
                        }

                        @Override
                        public void close() throws IOException {
                            // Nothing to close
                        }
                    };