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 =

            DefaultTransformNodeDependency transformNodeDependency = (DefaultTransformNodeDependency) node;
            for (TransformStepNode transformStepNode : transformNodeDependency.getNodes()) {
                resolveAction.execute(transformStepNode);
            }
            return true;
        }
        return false;
    }

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

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

    /**

        buildFile << """
            apply plugin: 'java-library'
        """

        when:
        def project = withConnection { connection -> connection.getModel(CppProject.class) }

        then:
        project.projectIdentifier.projectPath == ':'
        project.projectIdentifier.buildIdentifier.rootDir == projectDir
        project.mainComponent == null

public class HttpResponse {
    private int code;
    private String message;

    public HttpResponse(int code, String message) {
        this.code = code;
        this.message = message;
    }

    public int getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }

    @Override
    public String toString() {
        return "HTTP " + code + ", Reason: " + message;

    @Nonnull
    List<Artifact> getArtifacts();

    /**
     * Returns the project model.
     */
    @Nonnull
    Model getModel();

    /**
     * Shorthand method.
     */
    @Nonnull
    default Build getBuild() {
        Build build = getModel().getBuild();
        return build != null ? build : Build.newInstance();
    }

    /**

        }
        final ModelIdentifier modelIdentifier = modelMapping.getModelIdentifierFromModelType(type);
        BuildResult<?> result;
        try {
            result = builder.getModel(modelIdentifier, new BuildCancellationTokenAdapter(operationParameters.getCancellationToken()), operationParameters);
        } catch (InternalUnsupportedModelException e) {
            throw Exceptions.unknownModel(type, e);

     * @throws InternalUnsupportedModelException When the requested model is not supported.
     * @since 1.8-rc-1
     * @deprecated 4.4. Use {@link InternalBuildControllerVersion2#getModel(Object, ModelIdentifier, Object)} instead.
     */
    @Deprecated
    BuildResult<?> getModel(Object target, ModelIdentifier modelIdentifier) throws BuildExceptionVersion1,
            InternalUnsupportedModelException;

            componentState.setState(state, graphState);
        }
        return componentState;
    }

    public Collection<NodeState> getNodes() {
        return nodes.values();
    }

    public NodeState getNode(ComponentState component, VariantGraphResolveState variant, boolean selectedByVariantAwareResolution) {

        listener.connectionClosed(this);
    }

    void disconnect() {
        connection.disconnect();
    }

    @Override
    public <T> T getModel(Class<T> modelType) {
        return model(modelType).get();
    }

    @Override
    public <T> void getModel(final Class<T> modelType, final ResultHandler<? super T> handler) {
        model(modelType).get(handler);
    }

    @Override