try {
      getList().add(0, e0());
      fail("add(n, present) should throw");
    } catch (UnsupportedOperationException expected) {
    }
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_ADD_WITH_INDEX)
  public void testAddAtIndex_supportedNotPresent() {
    getList().add(0, e3());
    expectAdded(0, e3());
  }

  @CollectionFeature.Require(FAILS_FAST_ON_CONCURRENT_MODIFICATION)

TEST(ScopeTest, CreateOutput) {
  Scope root = Scope::NewRootScope();
  Output a = ops::Placeholder(root.WithOpName("a"), DT_FLOAT);
  Output add;
  ASSERT_TRUE(
      CreateOutputWithScope("Add", {a, a}, root.WithOpName("add"), &add).ok());
  EXPECT_EQ(add.node()->name(), "add");
  EXPECT_EQ(add.node()->type_string(), "Add");
}

            (
                "--add-opens=java.base/java.util=ALL-UNNAMED," +
                    "--add-opens=java.base/java.lang=ALL-UNNAMED," +
                    "--add-opens=java.base/java.lang.invoke=ALL-UNNAMED," +
                    "--add-opens=java.prefs/java.util.prefs=ALL-UNNAMED," +
                    "--add-opens=java.base/java.nio.charset=ALL-UNNAMED," +
                    "--add-opens=java.base/java.net=ALL-UNNAMED," +

        when:
        container.add('foo', extension)

        then:
        container.foo == extension
    }

    def "cannot replace an extension"() {
        given:
        container.add('foo', extension)

        when:
        container.add('foo', 'other')

        then:
        IllegalArgumentException e = thrown()

    /**
     * Add the created action message for the key 'errors.front_header' with parameters.
     * <pre>
     * message:
     * </pre>
     * @param property The property name for the message. (NotNull)
     * @return this. (NotNull)
     */
    public FessMessages addErrorsFrontHeader(String property) {
        assertPropertyNotNull(property);
        add(property, new UserMessage(ERRORS_front_header));

        return collector.hasProblems();
    }

    @Override
    public void add(String problem) {
        collector.add(problem);
    }

    @Override
    public void add(Field field, String problem) {
        collector.add(field, problem);
    }

    @Override
    public void add(MethodRuleDefinition<?, ?> method, String problem) {
        add(method.getMethod().getMethod(), problem);
    }

    @Override

	MOVD	(R3), R12
	CMPB	R12, R5, R12
	POPCNTD	R12, R12
	ADD	R12, R18, R18
	ADD	$8, R3, R3
	ADD	$-8, R4, R4

tail_4:	// Count the remaining 0 - 7 bytes.
	CMP	R4, $4
	BLT	tail_2
	MOVWZ	(R3), R12
	CMPB	R12, R5, R12
	SLD	$32, R12, R12	// Remove non-participating matches.
	POPCNTD	R12, R12
	ADD	R12, R18, R18
	ADD	$4, R3, R3
	ADD	$-4, R4, R4

tail_2:	// Count the remaining 0 - 3 bytes.

	expected := dedent.Dedent(`
		add table ip kube-proxy { comment "rules for kube-proxy" ; }

		add chain ip kube-proxy mark-for-masquerade
		add rule ip kube-proxy mark-for-masquerade mark set mark or 0x4000
		add chain ip kube-proxy masquerading
		add rule ip kube-proxy masquerading mark and 0x4000 == 0 return
		add rule ip kube-proxy masquerading mark set mark xor 0x4000
		add rule ip kube-proxy masquerading masquerade fully-random

        when:
        source.add("a")

        then:
        source.iterator().collect() == ["b", "a"]
    }

    def "can re-add an ordinary value after clear"() {
        when:
        source.add("a")
        source.add("b")
        source.clear()

        then:
        source.iterator().collect() == []

        when:
        source.add("a")
        source.add("b")

        then:

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

		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*2*goarch.PtrSize)
		}