mainMethod.invoke(null)
        } else {
          mainMethod.invoke(null, arrayOf<String>())
        }
      } else {
        System.err.println("No main for $className")
      }
    } catch (ite: InvocationTargetException) {
      if (!expectedFailure(className, ite.cause!!)) {
        throw ite.cause!!
      }
    }
  }

  @Suppress("UNUSED_PARAMETER")
  private fun expectedFailure(

    setDefault(EndpointPair.class, EndpointPair.ordered("A", "B"));
  }

  @Override
  public void testNulls() throws Exception {
    try {
      super.testNulls();
    } catch (AssertionError e) {
      assertWithMessage("Method did not throw null pointer OR element not in graph exception.")
          .that(e)
          .hasCauseThat()
          .hasMessageThat()

     * they are filtered locally by the default accept method).
     *
     * @param wildcard the wildcard pattern for matching file names (e.g., "*.txt")
     * @param attributes the DOS file attributes to match (e.g., ATTR_DIRECTORY)
     */
    public DosFileFilter(final String wildcard, final int attributes) {
        this.wildcard = wildcard;
        this.attributes = attributes;
    }

    /**

        if (server == null) {
            server = "\\\\";
        }
        final MsrpcSamrConnect4 rpc = new MsrpcSamrConnect4(server, access, this);
        try {
            handle.sendrecv(rpc);
        } catch (final DcerpcException de) {
            if (de.getErrorCode() != DcerpcError.DCERPC_FAULT_OP_RNG_ERROR) {
                throw de;
            }

      try {
        logger
            .get()
            .log(
                SEVERE,
                String.format(Locale.ROOT, "Caught an exception in %s.  Shutting down.", t),
                e);
      } catch (Throwable errorInLogging) { // sneaky checked exception
        // If logging fails, e.g. due to missing memory, at least try to log the
        // message and the cause for the failed logging.

 * Result result = cache.request(myRequest, req -> {
 *     // Expensive operation to compute result
 *     return computedResult;
 * });
 * </pre>
 * <p>
 * The package also provides support for batch operations through {@link org.apache.maven.api.cache.BatchRequestException}
 * and {@link org.apache.maven.api.cache.RequestResult} which help manage multiple requests and their results.
 *
 * @since 4.0.0
 */
@Experimental

        DEFAULT_PASSWORD = Config.getProperty("jcifs.smb1.smb.client.password", null);
        String defaultWorkstation = null;
        try {
            defaultWorkstation = NbtAddress.getLocalHost().getHostName();
        } catch (final UnknownHostException ex) {}
        DEFAULT_WORKSTATION = defaultWorkstation;
        LM_COMPATIBILITY = Config.getInt("jcifs.smb1.smb.lmCompatibility", 3);
    }

    /**

	err := g.g.apply(ctx).Find(&r).Error
	return r, err
}

func (g execG[T]) FindInBatches(ctx context.Context, batchSize int, fc func(data []T, batch int) error) error {
	var data []T
	return g.g.apply(ctx).FindInBatches(&data, batchSize, func(tx *DB, batch int) error {
		return fc(data, batch)
	}).Error
}

func (g execG[T]) Row(ctx context.Context) *sql.Row {
	return g.g.apply(ctx).Row()
}

    }

    @Override
    public void remove() {
      iterator.remove();
    }
  }

  public void testPeekingIteratorDoesntAdvancePrematurely() throws Exception {
    /*
     * This test will catch problems where the underlying iterator
     * throws a RuntimeException when retrieving the nth element.
     *
     * If the PeekingIterator is caching elements too aggressively,

        //    } else {
        //        return null;
        //    }
        //}
        //try {
        //    return CDef.DefMeta.valueOf(searchName);
        //} catch (IllegalArgumentException ignored) { // not found
        //    return null; // handled later
        //}
    }

    @Override
    public OptionalThing<String> determineAlias(final Locale locale) {