@Override
            public Optional<FileSystemNode> handleAsDescendantOfChild(VfsRelativePath pathInChild, T child) {
                return child.getNode(pathInChild, caseSensitivity);
            }

            @Override
            public Optional<FileSystemNode> handleAsAncestorOfChild(String childPath, T child) {
                return Optional.of(child);
            }

        }

        actualIds == expectedIds
    }

    CapabilitiesConflictHandler.Candidate candidate(CapabilityInternal cap, ComponentState co) {
        Mock(CapabilitiesConflictHandler.Candidate) {
            getNode() >> node(co)
            getCapability() >> cap
            getImplicitCapabilityProviders() >> []
        }
    }

    ComponentState component(String group="group", String name="name", String version="1.0") {

		}
	}
}

// GetObjectTTLFromNodeFunc returns a function that returns TTL value
// from a given Node object.
func GetObjectTTLFromNodeFunc(getNode func() (*v1.Node, error)) GetObjectTTLFunc {
	return func() (time.Duration, bool) {
		node, err := getNode()
		if err != nil {
			return time.Duration(0), false
		}
		if node != nil && node.Annotations != nil {

        assert lockOptions.getMode() == Shared;
        this.cacheDisplayName = cacheDisplayName;
        this.lockTarget = lockTarget;
        this.lockOptions = lockOptions;
        this.lockManager = lockManager;

    }

    def "model can be fetched via connection "() {
        when:
        EclipseProject model = withConnection { connection ->
            connection.getModel(EclipseProject.class)
        }

        then:
        collectProjects(model).collect({ it.name }).contains("a")
    }

    def "model can be fetched without parameters"() {
        when:

        ideaProject.modules.find { it.name == 'child4' }.javaLanguageSettings == null
    }

    private IdeaProject loadIdeaProjectModel() {
        withConnection { connection -> connection.getModel(IdeaProject) }
    }

    private JavaVersion toJavaVersion(ideaLanguageLevel) {
        JavaVersion.valueOf(ideaLanguageLevel.level.replaceFirst("JDK", "VERSION"));
    }

    public Map<String, String> getEffectiveProperties(@Nullable Project project) {
        HashMap<String, String> result = new HashMap<>(getSystemProperties());
        if (project != null) {
            result.putAll(project.getModel().getProperties());
        }
        result.putAll(getUserProperties());
        return result;
    }

    @Nonnull
    @Override
    public Version getMavenVersion() {

  auto model_ptr = tflite::FlatBufferModel::VerifyAndBuildFromBuffer(
      buffer.data(), buffer.size());
  if (nullptr == model_ptr) {
    return std::nullopt;
  }
  std::unique_ptr<tflite::ModelT> model(model_ptr->GetModel()->UnPack());

  // FB-LABEL:     name: "arg0",
  // FB-NEXT:      quantization: {
  // FB-NEXT:              min: [ -1.0 ],
  // FB-NEXT:              max: [ 1.0 ]
  // FB-NEXT:      }

                    return Optional.ofNullable(res.getDependencyResolutionResult())
                            .map(r -> new DefaultDependencyResolverResult(
                                    null, r.getCollectionErrors(), session.getNode(r.getDependencyGraph()), 0));
                }
            };
        } catch (ProjectBuildingException e) {
            throw new ProjectBuilderException("Unable to build project", e);
        }
    }

        assert binder.isBound() : "RuleBinder must be in a bound state";
        for (ModelBinding inputBinding : binder.getInputBindings()) {
            ModelNodeInternal node = inputBinding.getNode();
            if (dependencies == null) {
                dependencies = new HashSet<>();
            }
            dependencies.add(node);
            if (node.dependents == null) {