collection.visitDependencies(Stub(TaskDependencyResolveContext))

        then:
        registry.state("tasks.redundant") == ModelNode.State.Discovered
    }

    def "realize is idempotent"() {
        given:
        ModelRegistryHelper registry = new ModelRegistryHelper()
        ModelPath path = ModelPath.path("tasks")

        registry.registerInstance("tasks", "foo tasks")

     * Formats and prints the number of diagnostics of a given kind.
     * <p>
     * E.g.:
     * <pre>
     * 1 error
     * 2 warnings
     * </pre>
     *
     * @param logger the logger used to localize the message
     * @param kind the kind of diagnostic (error, or warn)
     * @param number the total number of diagnostics of the given kind
     */

    /**
     * ローカルの{@link TimeZone}と{@link Locale}をもつ{@link Calendar}に変換します。
     *
     * @param calendar
     *            {@link Calendar}
     * @return 変換された{@link Calendar}
     */
    public static Calendar localize(final Calendar calendar) {
        assertArgumentNotNull("calendar", calendar);
        final Calendar localCalendar = Calendar.getInstance();
        localCalendar.setTimeInMillis(calendar.getTimeInMillis());

        // Configure task through suite
        testing {
            suites {
                test {
                    useJUnitJupiter()
                    targets.all {
                        // explicitly realize the task now to cause this configuration to run now
                        testTask.get().configure {
                            options {
                                includeTags 'fast'
                            }

        _ * provider2.present >> true
        _ * provider3.type >> otherType
        container.addLater(provider1)
        container.addLater(provider2)
        container.addLater(provider3)

        // Realize all object of type `type`
        toList(container.withType(type))

        when:
        def didRemoved1 = container.remove(provider1)

        then:
        didRemoved1

        and:

        }

        return gradleProject;
    }

    private static List<LaunchableGradleProjectTask> collectTasks(DefaultGradleProject owner, TaskContainerInternal tasks) {
        tasks.discoverTasks();
        tasks.realize();

        return tasks.getNames().stream()
            .map(tasks::findByName)
            .filter(Objects::nonNull)
            .map(task -> buildTask(owner, task))
            .collect(toList());
    }

class ForceRealizedMetadataIntegrationTest extends AbstractHttpDependencyResolutionTest {
    MavenHttpModule direct
    MavenHttpModule transitive

    def setup() {
        executer.withArgument("-Dorg.gradle.integtest.force.realize.metadata=true")

        buildFile << """
            plugins {
                id 'java'
            }

            repositories {
                maven { url '$mavenHttpRepo.uri' }
            }

        when:
        dsl {
            apply plugin: BinaryBasePlugin
            model {
                baseBinary(BinarySpec) {
                }
            }
        }

        then:
        realize("baseBinary") instanceof BinarySpec
    }

    def "adds a 'binaries' container to the project model"() {
        when:
        dsl {
            apply plugin: BinaryBasePlugin
        }

        then:

  EXPECT_FALSE(IsDynamicPadderOp(TypeID::get<TF::ConstOp>()));
}

// This test is kind of odd. We go through all the Tensorflow types and check
// whether they are legalized with MLIR, TF2XLA, or both. Ideally the sets are
// disjoint, but until that happens, this tests ensures that the set doesn't
// grow.
TEST_F(LegalizationOpConfigTest, CountLoweringsSet) {
  int mlir_lowering_count = 0;

        dsl {
            apply plugin: TestingModelBasePlugin
            model {
                baseComponent(TestSuiteSpec) {
                }
            }
        }

        then:
        realize("baseComponent") instanceof TestSuiteSpec
    }

    def "adds a 'testSuites' container to the project model"() {
        when:
        dsl {
            apply plugin: TestingModelBasePlugin
        }