@Mutate
            void addTasks(ModelMap<Task> tasks) {
                tasks.create("actionMan", EchoTask) {
                    text = 'This is your commander speaking'
                }
                tasks.create("climbTask", ClimbTask) {}
                tasks.create("jumpTask", JumpTask) {}
                tasks.create("overruleTask", OverruleTask) {}
            }
        }
        apply type: Rules

                        HashBasedTable.<String, Integer, Character>create());
                  }

                  @Override
                  public Set<Cell<String, Integer, Character>> create(Object... elements) {
                    Table<String, Integer, Character> table = HashBasedTable.create();
                    for (Object element : elements) {

        [child1, child2, child3].each {
            it.configurations.create "testRuntime"
            it.configurations.create "conf"
            it.tasks.create "buildDependents"
            it.tasks.create "someTask"
        }

        when: dep.visitDependencies(context)

        then:
        4 * context.getTask() >> child1.tasks["buildDependents"]

        EclipseClasspathFixture.create(testDirectory, executer.gradleUserHomeDir)
    }

    protected EclipseClasspathFixture classpath(String project) {
        EclipseClasspathFixture.create(testDirectory.file(project), executer.gradleUserHomeDir)
    }

    protected EclipseWtpComponentFixture getWtpComponent() {
        EclipseWtpComponentFixture.create(testDirectory)
    }

    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": {

        }
        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.")
    }

        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")

    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();