setup:
        1 * versionDetails.maySupportModel(SomeModel.class) >> false
        when:
        modelProducer.produceModel(SomeModel.class, Mock(ConsumerOperationParameters))
        then:
        0 * builder.getModel(_, _, _)
        def e = thrown(UnknownModelException)

        when:
        def model = withConnection { getModel(HierarchicalEclipseProject) }

        then:
        model.name == 'module-root'
    }

    def "Eclipse model builder can handle indirect cycles between included builds"() {
        given:
        compositeWithIndirectIncludeCycle()

        when:
        def model = withConnection { getModel(HierarchicalEclipseProject) }

        then:

    public MavenProject getProject() {
        return project;
    }

    public List<Dependency> getDependencies() {
        return project.getModel().getDependencies();
    }

    public List<Dependency> getManagedDependencies() {
        DependencyManagement depMngt = project.getModel().getDependencyManagement();
        return (depMngt != null) ? Collections.unmodifiableList(depMngt.getDependencies()) : Collections.emptyList();
    }

        when:
        BuildEnvironment env = toolingApi.withConnection { connection ->
            connection.newBuild().run() //the assert
            connection.getModel(BuildEnvironment.class)
        }

        then:
        env.java.jvmArguments.contains('-Xmx62m')
    }

    def "tooling api honours java home specified in gradle.properties"() {

            AllProjects result = new AllProjects();

            GradleBuild buildModel = controller.getBuildModel();
            result.rootBuild = buildModel;
            result.rootIdeaProject = controller.getModel(IdeaProject.class);

            collectAllNestedBuilds(buildModel, controller, result);

            result.allIdeaProjects.add(result.rootIdeaProject);

    ) : ToolingModelScope {
        override fun getTarget() = delegate.target

        override fun getModel(modelName: String, parameter: ToolingModelParameterCarrier?): Any? {
            return cache.loadOrCreateIntermediateModel(target?.identityPath, modelName, parameter) {
                delegate.getModel(modelName, parameter)
            }
        }
    }

    stat.getExpression().visit(this);
    stat.setCode(replace(stat.getCode()));
  }

  @Override
  public void visitSynchronizedStatement(SynchronizedStatement stat) {
    stat.getExpression().visit(this);
    stat.setCode(replace(stat.getCode()));
  }

  @Override
  public void visitCatchStatement(CatchStatement stat) {
    stat.setCode(replace(stat.getCode()));
  }

  @Override

        def model = withConnection(connector) { it.getModel(modelType) }
        return toGradleProject(model)
    }

    private <T> T getModelWithProjectConnection(TestFile rootDir, Class<T> modelType) {
        def connector = connector()
        connector.forProjectDirectory(rootDir.absoluteFile)
        return withConnection(connector) { it.getModel(modelType) }
    }

  std::string expected_value = "test_data";

  // Load input model
  auto input_fbm = tflite::FlatBufferModel::BuildFromFile(
      "tensorflow/lite/testdata/sparse_tensor.bin");
  tflite::ModelT input_model;
  input_fbm->GetModel()->UnPackTo(&input_model);

  // Populate input metadata
  auto model_metadata_buffer = std::make_unique<tflite::BufferT>();
  model_metadata_buffer->data =

        @Override
        public ScheduledNodes getScheduledNodes() {
            return visitor -> visitor.accept(Collections.emptyList(), Collections.emptySet());
        }

        @Override
        public TaskNode getNode(Task task) {
            throw new IllegalStateException();
        }
    };

    /**