*/
public class NdrException extends IOException {

    /**
     * Error message for null reference pointers.
     */
    public static final String NO_NULL_REF = "ref pointer cannot be null";

    /**
     * Error message for invalid array conformance.
     */
    public static final String INVALID_CONFORMANCE = "invalid array conformance";

    /**
     * Constructs an NdrException with the specified error message.
     *

     * @param policyHandle the LSA policy handle
     * @param level the information level to query
     * @param info the object to store the query results
     */
    public MsrpcQueryInformationPolicy(final LsaPolicyHandle policyHandle, final short level, final NdrObject info) {
        super(policyHandle, level, info);
        ptype = 0;
        flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;
    }

     *
     * @param server the server name to connect to
     * @param access the desired access rights
     * @param policyHandle the policy handle to be populated
     */
    public MsrpcSamrConnect4(final String server, final int access, final SamrPolicyHandle policyHandle) {
        super(server, 2, access, policyHandle);
        ptype = 0;
        flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;
    }

                    .collect(Collectors.toList())
            ).getAsFileTree();

            final Map<String, Set<File>> classFilesPerTask = getClassFilesPerEnabledTask();

            final Set<File> testSourceSetFiles = Util.getJavaTestSourceSet(getProject()).get().getRuntimeClasspath().getFiles();
            final Map<String, Set<Class<?>>> testClassesPerTask = classFilesPerTask.entrySet()
                .stream()

    public void testConcurrentSecureWipe() throws InterruptedException {
        final NtlmPasswordAuthenticator auth = new NtlmPasswordAuthenticator("user", "ConcurrentWipePass123!");
        final int threadCount = 20;
        final CountDownLatch startLatch = new CountDownLatch(1);
        final CountDownLatch completeLatch = new CountDownLatch(threadCount);

import org.w3c.dom.Element;

import java.util.Collection;

class BlocksRenderer implements ClassDocMemberRenderer {
    private final BlockTableRenderer blockTableRenderer = new BlockTableRenderer();
    private final ExtensionBlocksSummaryRenderer extensionBlocksSummaryRenderer;
    private final BlockDetailRenderer blockDetailRenderer;

    public BlocksRenderer(LinkRenderer linkRenderer, GenerationListener listener) {

 *
 * @author Sven Mawson
 */
@NullUnmarked
@GwtIncompatible
@J2ktIncompatible
public class ListenableFutureTester {

  private final ExecutorService exec;
  private final ListenableFuture<?> future;
  private final CountDownLatch latch;

  public ListenableFutureTester(ListenableFuture<?> future) {
    this.exec = newCachedThreadPool();
    this.future = checkNotNull(future);

public class DurableHandleReconnect implements CreateContextRequest {

    /**
     * Context name for durable handle reconnect
     */
    public static final String CONTEXT_NAME = "DHnC";

    private static final byte[] CONTEXT_NAME_BYTES = CONTEXT_NAME.getBytes();
    private static final int STRUCTURE_SIZE = 16;

    private byte[] fileId; // 16-byte file ID from previous open

    /**
     * Create a new durable handle reconnect context

@Deprecated(since = "4.0.0")
public class TypeCollector implements DependencyGraphTransformer {

    public static final Object CONTEXT_KEY = TypeCollector.class.getName() + ".processorTypes";

    static final Set<String> PROCESSOR_TYPE_IDS =
            Set.of(Type.PROCESSOR, Type.CLASSPATH_PROCESSOR, Type.MODULAR_PROCESSOR);

    private static final Map<String, String> DERIVE_MAP = Map.of(
            Type.JAR, Type.PROCESSOR,

    private final List<Suppression> suppressions = new ArrayList<>();

    @Override
    public void suppress(Closeable closeable, Throwable thrown, Throwable suppressed) {
      suppressions.add(new Suppression(closeable, thrown, suppressed));
    }
  }

  /** Record of a call to suppress. */
  private static class Suppression {
    private final Closeable closeable;