import org.gradle.api.internal.project.ProjectState;
import org.gradle.tooling.provider.model.UnknownModelException;

import javax.annotation.Nullable;

/**
 * A scope that allows {@link #getModel(String, ToolingModelParameterCarrier) building models}
 * for a given {@link #getTarget() target}.
 */
public interface ToolingModelScope {

    /**

        renderTestResultList(htmlWriter, getResults().getIgnored());
    }

    @Override
    protected String getTitle() {
        return getModel().getTitle();
    }

    @Override
    protected String getPageTitle() {
        return "Test results - " + getModel().getTitle();
    }

    @Override
    protected ReportRenderer<T, SimpleHtmlWriter> getHeaderRenderer() {

//   EXPECT_THAT(status, Eq(kTfLiteOk));
//   const Model* output_model = GetModel(output_buffer_.data());
//   ASSERT_TRUE(output_model);
// }

class QuantizeSplitModelTest : public QuantizeModelTest {
 protected:
  QuantizeSplitModelTest() {
    input_model_ = ReadModel(internal::kModelSplit);
    readonly_model_ = input_model_->GetModel();
    model_ = UnPackFlatBufferModel(*readonly_model_);
  }
};

                return controller.getModel(project, SomeToolingModel.class);
            }
        }
        for (GradleBuild editableBuild : buildModel.getEditableBuilds()) {
            for (BasicGradleProject project : editableBuild.getProjects()) {
                if (targetProject.equals(project.getBuildTreePath())) {
                    return controller.getModel(project, SomeToolingModel.class);
                }

    public String execute(BuildController controller) {
        CustomProjectsLoadedModel model;
        if (tasks == null || tasks.isEmpty()) {
            model = controller.getModel(CustomProjectsLoadedModel.class);
        } else {
            model = controller.getModel(CustomProjectsLoadedModel.class, CustomParameter.class, new Action<CustomParameter>() {
                @Override
                public void execute(CustomParameter customParameter) {

        for (BasicGradleProject project : controller.getBuildModel().getProjects()) {
            result.put(project.getPath(), controller.getModel(project, CustomModel.class));
        }

        CustomModel rootProjectModel = controller.getModel(controller.getBuildModel().getRootProject(), CustomModel.class);
        for (CustomModel customModel : result.values()) {

    }

    /**
     * getter
     */
    public MetadataGraphNode getEntry() {
        return entry;
    }

    /**
     * getter
     */
    public Collection<MetadataGraphNode> getNodes() {
        return nodes;
    }

        if (workspace != null) {
            models.add(controller.getModel(build.getRootProject(), modelClass, EclipseRuntime.class, new EclipseRuntimeAction(workspace)));
        } else {
            models.add(controller.getModel(build.getRootProject(), modelClass));
        }
        for (GradleBuild includedBuild : build.getIncludedBuilds()) {

	return errNotImplemented
}

// GetConsumption -- dummy implementation
func GetConsumption(_ string) (*resource.Quantity, error) {
	return nil, errNotImplemented
}

// GetInodes -- dummy implementation
func GetInodes(_ string) (*resource.Quantity, error) {
	return nil, errNotImplemented
}

// ClearQuota -- dummy implementation
func ClearQuota(_ mount.Interface, _ string) error {
	return errNotImplemented

    }

    @Override
    public EclipseProject execute(BuildController controller) {
        if (workspace != null) {
            return controller.getModel(EclipseProject.class, EclipseRuntime.class, new EclipseRuntimeAction(workspace));
        }
        return controller.getModel(EclipseProject.class);
    }

    private static class EclipseRuntimeAction implements Action<EclipseRuntime>, Serializable {