def __init__(self, *args, **kwargs) -> None: ...
    def create(self, arg0: Location, arg1: list[Value]) -> Operation: ...

class Tf_AddV2Op:
    def __init__(self, *args, **kwargs) -> None: ...
    def create(self, arg0: Location, arg1: Value, arg2: Value) -> Operation: ...

class Tf_AnyOp:
    def __init__(self, *args, **kwargs) -> None: ...
    def create(self, arg0: Location, arg1: Value, arg2: Value, arg3: bool) -> Operation: ...

        def finalReadOnlyBean = create(HasReadOnlyFinalProperty, Describables.of("<display name>"))
        def readOnlyBean = create(HasReadOnlyProperty, Describables.of("<display name>"))
        def readOnlyBeanWithMapping = create(HasReadOnlyProperty, Describables.of("<display name>"))
        readOnlyBeanWithMapping.conventionMapping.map("other") { "ignore" }

		expectError    string
	}{
		"create allowed, enabled": {
			operation:      admission.Create,
			obj:            sliceNode,
			featureEnabled: true,
			expectError:    "",
		},
		"create disallowed, enabled": {
			operation:      admission.Create,
			obj:            sliceOtherNode,
			featureEnabled: true,
			expectError:    err,
		},
		"create allowed, disabled": {

        def bean = create(Bean)

        expect:
        !(bean instanceof Managed)
    }

    def doesNotMixManagedIntoAbstractClassWithFields() {
        def bean = create(AbstractBean, "value")

        expect:
        !(bean instanceof Managed)
    }

    def doesNotMixManagedIntoClassWithInheritedFields() {
        def bean = create(AbstractBeanWithInheritedFields, "value")

        }
        apply plugin: Rules

        model {
            components {
                withType(SampleComponent).create("other", NonRegisteredComponent)
            }
        }
        """

        expect:
        fails "components"
        failure.assertHasCause("Cannot create an instance of type 'NonRegisteredComponent' as this type is not known. Known types: SampleComponent.")
    }

    try {
      HashMultimap.create(-20, 15);
      fail();
    } catch (IllegalArgumentException expected) {
    }

    try {
      HashMultimap.create(20, -15);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testEmptyMultimapsEqual() {
    Multimap<String, Integer> setMultimap = HashMultimap.create();

        rewriter.create<SubtractOp>(loc, b_max_diag_len, diag_len_d), b_zero);

    // x = max(d, 0) - offset
    // y = max(-d, 0) - offset
    Value x = rewriter.create<SubtractOp>(
        loc, rewriter.create<MaxOp>(loc, d, b_zero), offset);
    Value y = rewriter.create<SubtractOp>(
        loc, rewriter.create<MaxOp>(loc, neg_d, b_zero), offset);

    Value n_plus_x = rewriter.create<AddOp>(loc, iotaN, x);

    @Override
    public StyledTextOutput create(Class<?> logCategory) {
        return create(logCategory.getName());
    }

    @Override
    public StyledTextOutput create(String logCategory) {
        return create(logCategory, null);
    }

    @Override
    public StyledTextOutput create(Class<?> logCategory, LogLevel logLevel) {
        return create(logCategory.getName(), logLevel);
    }

    return suite;
  }

  protected LinkedListMultimap<String, Integer> create() {
    return LinkedListMultimap.create();
  }

  /** Confirm that get() returns a List that doesn't implement RandomAccess. */
  public void testGetRandomAccess() {
    Multimap<String, Integer> multimap = create();
    multimap.put("foo", 1);
    multimap.put("foo", 3);

                componentSpecs.create("sampleLib")
            }

            @ComponentBinaries
            void createBinariesForSampleLibrary(ModelMap<SampleBinary> binaries, SampleLibrary library) {
                binaries.create("binaryOne")
                binaries.create("binaryTwo")
            }
        }
        apply plugin:MyComponentBasePlugin

        """