file("a/build.gradle") << ""
        file("b/build.gradle") << ""

        when:
        def originalModel = fetchModel(GradleProject)

        then:
        fixture.assertNoConfigurationCache()

        when:
        executer.withArguments(ENABLE_CLI)
        def model = fetchModel(GradleProject)

        then:
        fixture.assertStateStored {

        when:
        executer.withArguments(ENABLE_CLI)
        fetchModel(SomeToolingModel, "help")

        then:
        notExecuted("help")
        fixture.assertStateStored {
            projectsConfigured(":buildSrc", ":")
            modelsCreated(":")
        }

        when:
        executer.withArguments(ENABLE_CLI)
        fetchModel(SomeToolingModel, ":dummyTask")

        then:

        def ideaModel = fetchModel(IdeaProject)

        then:
        fixture.assertStateStored {
            modelsCreated(":", models(IdeaProject, pluginApplyingModel, IsolatedGradleProjectInternal, IsolatedIdeaModuleInternal))
        }

        then:
        ideaModel.name == "root"

        when:
        executer.withArguments(ENABLE_CLI)
        fetchModel(IdeaProject)

        then:

        """)
        withBuildScript()
        withBuildScriptIn("a")

        when:
        def originalModel = fetchModel(KotlinDslScriptsModel)

        then:
        fixture.assertNoConfigurationCache()


        when:
        withIsolatedProjects()
        def model = fetchModel(KotlinDslScriptsModel)

        then:
        fixture.assertStateStored {
            modelsCreated(":", KotlinDslScriptsModel)

        buildWithSomeToolingModelAndScriptLogStatement()

        when:
        def model = fetchModel()

        then:
        model.message == "It works from project :"
        outputContains("script log statement")

        when:
        def model2 = fetchModel()

        then:
        model2.message == "It works from project :"
        outputContains("script log statement")

        List<Supplier<Object>> fetchActions = targets.stream()
            .map(targetProject -> (Supplier<Object>) () -> fetchModel(modelName, controller, (ProjectInternal) targetProject, parameter))
            .collect(toList());

        return runFetchActions(fetchActions);
    }

    @Nullable

                        id = "$pluginId"
                        implementationClass = "$implClass"
                    }
                }
            }
        """
    }

    def <T> T fetchModel(Class<T> type = SomeToolingModel.class, String... tasks = null) {
        def model = null
        result = toolingApiExecutor.runBuildWithToolingConnection { connection ->
            def output = new ByteArrayOutputStream()

        given:
        server.expect("configure-root")
        server.expectConcurrent("configure-a", "configure-b")

        when:
        executer.withArguments(ENABLE_CLI)
        def model = fetchModel(GradleProject)

        then:
        model.name == "root"
        model.children.name == ["a", "b"]

        and:
        fixture.assertStateStored {
            projectsConfigured(":", ":a", ":b")

                                          lens[i])) != nodes_preserved.end(),
              true);
  }
  TF_DeleteStatus(status);
}

TEST(TF_GrapplerItem, FetchNodes) {
  GrapplerItem item;
  item.fetch = std::vector<string>{"Conv", "BiasAdd"};
  TF_GrapplerItem* c_item = reinterpret_cast<TF_GrapplerItem*>(&item);

  int list_total_size = 0;