public IngestFactory() {
        // Default constructor
    }

    /**
     * Adds an ingester to the factory.
     * The ingester is inserted into the collection and the array is re-sorted by priority.
     * This method is thread-safe.
     *
     * @param ingester the ingester to add
     */
    public synchronized void add(final Ingester ingester) {
        if (logger.isDebugEnabled()) {

    @Override
    public void apply(Project project) {
        configureRepositories(project);
    }

    /**
     * Adds repositories used by ES projects and dependencies
     */
    public static void configureRepositories(Project project) {
        RepositoryHandler repos = project.getRepositories();

            assertEquals("server/", root.getName());
        }
    }

    @Mock
    DfsReferralData dfs;
    @Mock
    Address addr;

    @Test
    @DisplayName("Mockito interaction – dependent objects are called appropriately")
    void testInteractionsWithStubbedDependencies() throws Exception {
        String url = "smb://server/share/";

    static NbtAddress[] dc_list = null;
    static long dc_list_expiration;
    static int dc_list_counter;

    private static NtlmChallenge interrogate(final NbtAddress addr) throws SmbException {
        final UniAddress dc = new UniAddress(addr);
        final SmbTransport trans = SmbTransport.getSmbTransport(dc, 0);
        if (USERNAME == null) {
            trans.connect();
            if (LogStream.level >= 3) {

Here's how the 386 runtime defines the 64-bit atomic load function.
</p>

<pre>
// uint64 atomicload64(uint64 volatile* addr);
// so actually
// void atomicload64(uint64 *res, uint64 volatile *addr);
TEXT runtime·atomicload64(SB), NOSPLIT, $0-12
	MOVL	ptr+0(FP), AX
	TESTL	$7, AX
	JZ	2(PC)
	MOVL	0, AX // crash with nil ptr deref
	LEAL	ret_lo+4(FP), BX

	ADDL $7, (BX)                           // 830307
	ADDL $7, (R11)                          // 41830307
	ADDL $7, DX                             // 83c207
	ADDL $7, R11                            // 4183c307
	ADDL DX, (BX)                           // 0113
	ADDL R11, (BX)                          // 44011b
	ADDL DX, (R11)                          // 410113
	ADDL R11, (R11)                         // 45011b

func TestCopyUnixpacket(t *testing.T) {
	tmpDir := t.TempDir()
	socket := filepath.Join(tmpDir, "unixsock")

	// Start a unixpacket server.
	addr := &net.UnixAddr{
		Name: socket,
		Net:  "unixpacket",
	}
	server, err := net.ListenUnix("unixpacket", addr)
	if err != nil {
		t.Skipf("skipping test because opening a unixpacket socket failed: %v", err)
	}

	// Start a goroutine for the server to accept one connection

    @CanIgnoreReturnValue
    public abstract Builder<E> add(E element);

    /**
     * Adds each element of {@code elements} to the {@code ImmutableCollection} being built.
     *
     * <p>Note that each builder class overrides this method in order to covariantly return its own
     * type.
     *
     * @param elements the elements to add
     * @return this {@code Builder} instance

 * a member of the group(a.k.a workgroup and domain) <code>BILLING-NY</code>. To
 * obtain an {@link java.net.InetAddress} for a host one might do:
 *
 * <pre>
 *
 * InetAddress addr = NbtAddress.getByName("jmorris2").getInetAddress();
 * </pre>
 *
 *  * From a UNIX platform with Samba installed you can perform similar
 * diagnostics using the <code>nmblookup</code> utility.
 *

                while (addresses.hasMoreElements()) {
                    InetAddress addr = addresses.nextElement();

                    // Estimate link speed (would need platform-specific code for actual speed)
                    int linkSpeed = ni.isVirtual() ? 100 : 1000; // Default 1Gbps

                    NetworkInterfaceInfo info = new NetworkInterfaceInfo(addr, linkSpeed);
                    if (info.isUsableForChannel()) {