nodesToRemove:  nil,
			operations:     []string{"add", "add", "add", "add", "add", "add"},
			expectedOutput: []string{"node-4", "node-5", "node-6", "node-3", "node-7", "node-8"},
		},
		{
			name:           "remove zone and add new",
			nodesToAdd:     append(allNodes[3:5:5], allNodes[6:8]...),
			nodesToRemove:  allNodes[3:5],
			operations:     []string{"add", "add", "remove", "add", "add", "remove"},

        options.add(new ProjectCacheDirOption());
        options.add(new RerunTasksOption());
        options.add(new ProfileOption());
        options.add(new ContinueOption());
        options.add(new OfflineOption());
        options.add(new RefreshDependenciesOption());
        options.add(new DryRunOption());
        options.add(new ContinuousOption());
        options.add(new ContinuousBuildQuietPeriodOption());

        getLanguageOption().ifPresent(args::add);
        args.add("/nologo");
        args.add("/c");
        if (spec.isDebuggable()) {
            args.add("/Zi");
        }
        if (spec.isOptimized()) {
            args.add("/O2");
        }
    }

    protected void addIncludeArgs(T spec, List<String> args) {
        for (File file : spec.getIncludeRoots()) {
            args.add("/I" + file.getAbsolutePath());
        }

		x.k = add(unsafe.Pointer(x.b), dataOffset)
		x.e = add(x.k, abi.MapBucketCount*4)

		if !h.sameSizeGrow() {
			// Only calculate y pointers if we're growing bigger.
			// Otherwise GC can see bad pointers.
			y := &xy[1]
			y.b = (*bmap)(add(h.buckets, (oldbucket+newbit)*uintptr(t.BucketSize)))
			y.k = add(unsafe.Pointer(y.b), dataOffset)
			y.e = add(y.k, abi.MapBucketCount*4)
		}

		for ; b != nil; b = b.overflow(t) {

        def list = new LinkedList()

        list.add('one')
        assertEquals(1, list.size())
        assertEquals('one', list.get(0))

        list.add('two')
        assertEquals(2, list.size())
        assertEquals('two', list.get(1))
    }

    @Test void testRemove() {
        def list = new LinkedList()

        list.add('one')
        list.add('two')
        assertTrue(list.remove('one'))

        val list = new LinkedList()

        list.add("one")
        assertEquals(1, list.size())
        assertEquals("one", list.get(0))

        list.add("two")
        assertEquals(2, list.size())
        assertEquals("two", list.get(1))
    }

    @Test def testRemove(): Unit = {
        val list = new LinkedList()

        list.add("one")
        list.add("two")
        assertTrue(list.remove("one"))

	MOV	24(X11), X17
	BNE	X14, X15, not_eq
	BNE	X16, X17, not_eq
	ADD	$32, X10
	ADD	$32, X11
	SUB	$32, X12
	BGE	X12, X9, loop32
	BEQZ	X12, eq

loop16_check:
	MOV	$16, X23
	BLT	X12, X23, loop4_check
loop16:
	MOV	0(X10), X19
	MOV	0(X11), X20
	MOV	8(X10), X21
	MOV	8(X11), X22
	BNE	X19, X20, not_eq
	BNE	X21, X22, not_eq
	ADD	$16, X10
	ADD	$16, X11
	SUB	$16, X12
	BGE	X12, X23, loop16
	BEQZ	X12, eq

	MOV	ZERO, X14	// count
	ADD	X10, X11	// end

	PCALIGN	$16
loop:
	BEQ	X10, X11, done
	MOVBU	(X10), X15
	ADD	$1, X10
	BNE	X12, X15, loop
	ADD	$1, X14
	JMP	loop

done:
	MOV	X14, X10
	RET

TEXT ·CountString<ABIInternal>(SB),NOSPLIT,$0-32
	// X10 = s_base
	// X11 = s_len
	// X12 = byte to count
	AND	$0xff, X12
	MOV	ZERO, X14	// count
	ADD	X10, X11	// end

	PCALIGN	$16
loop:

            if (spec instanceof SharedLibraryLinkerSpec) {
                args.add("-emit-library");
            } else if (spec instanceof BundleLinkerSpec) {
                args.add("-Xlinker");
                args.add("-bundle");
            } else {
                args.add("-emit-executable");
            }
            args.add("-o");
            args.add(spec.getOutputFile().getAbsolutePath());

     * @see [DependencyHandler.add]
     */
    operator fun Configuration.invoke(dependencyNotation: Any): Dependency? =
        add(name, dependencyNotation)

    /**
     * Adds a dependency to the given configuration.
     *
     * @param dependencyNotation notation for the dependency to be added.
     * @return The dependency.
     * @see [DependencyHandler.add]
     * @since 8.3
     */
    @Incubating