private void weaklyReferenceQueue() {
    frq = new FinalizableReferenceQueue();
    queueReference = new WeakReference<>(frq.queue);

    /*
     * Queue and clear a reference for good measure. We test later on that
     * the finalizer thread stopped, but we should test that it actually
     * started first.
     */
    reference =
        new FinalizableWeakReference<Object>(new Object(), frq) {
          @Override

        int pos = 0;
        for (int i = 0; i < 8; i++) {
            if (material[i] != NTLMSSP_SIGNATURE[i]) {
                throw new IOException("Not an NTLMSSP message.");
            }
        }
        pos += 8;

        if (readULong(material, pos) != NTLMSSP_TYPE1) {
            throw new IOException("Not a Type 1 message.");
        }
        pos += 4;

        final int flags = readULong(material, pos);

                        break;
                    default:
                        throw new SmbException("Invalid operation for " + service + " service");
                    }
                    break;
                default:
                    throw new SmbException("Invalid operation for " + service + " service" + request);
                }
            }
            request.tid = tid;

import org.apache.maven.project.MavenProject;

public class BuildPlan {

    private final Map<MavenProject, Map<String, BuildStep>> plan = new LinkedHashMap<>();
    private final Map<MavenProject, List<MavenProject>> projects;
    private final Map<String, String> aliases = new HashMap<>();
    private volatile Set<String> duplicateIds;
    private volatile List<BuildStep> sortedNodes;

    BuildPlan() {

    protected final Map<Key, CacheRecord> cache = new ConcurrentHashMap<>();

    @Override
    public Key createKey(
            Plugin plugin,
            ClassLoader parentRealm,
            Map<String, ClassLoader> foreignImports,
            DependencyFilter dependencyFilter,
            List<RemoteRepository> repositories,
            RepositorySystemSession session) {

            }
            localRepositoryPath = new File(path, "repository").getAbsolutePath();
        }

        try {
            return repositorySystem.createLocalRepository(new File(localRepositoryPath));
        } catch (Exception e) {
            throw new MavenExecutionRequestPopulationException("Cannot create local repository.", e);
        }
    }

        @DisplayName("writeSetupWireFormat returns 0 for all indices")
        void writeSetupWireFormatReturnsZero(int index) {
            TransWaitNamedPipeResponse resp = new TransWaitNamedPipeResponse();
            assertEquals(0, resp.writeSetupWireFormat(new byte[10], index), "writeSetupWireFormat should always return 0");
        }

        @ParameterizedTest
        @ValueSource(ints = { 0, 5, -5, Integer.MAX_VALUE })

        try {
            return new URL(null, spec, new Handler());
        } catch (MalformedURLException e) {
            throw new AssertionError("Failed to create SMB URL: " + spec, e);
        }
    }

    // Utility to build a minimal locator for connect tests
    private static SmbResourceLocatorImpl newLocator(CIFSContext ctx) {
        return new SmbResourceLocatorImpl(ctx, smbUrl("smb://server/share"));
    }

        assertEquals(1, mavenProject.getArtifacts().size());

        final MavenProject project = mavenProject;
        final AtomicInteger artifactsResultInAnotherThread = new AtomicInteger();
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                artifactsResultInAnotherThread.set(project.getArtifacts().size());
            }
        });

        this.docRoot = docRoot;

        server = new Server(port);

        final ResourceHandler resource_handler = new ResourceHandler();
        resource_handler.setWelcomeFiles(new String[] { "index.html" });
        resource_handler.setResourceBase(docRoot.getAbsolutePath());
        Log.info("serving " + resource_handler.getBaseResource());
        final HandlerList handlers = new HandlerList();