LibraryBinaryIdentifier getId();

    String getProjectScopedName();

    boolean isBuildable();

    boolean isTestSuite();

    List<DependentBinariesResolvedResult> getChildren();

    ComponentSelectionReason getReason();

    List<ResolvedVariantResult> getSelectedVariants();

    List<ResolvedVariantResult> getAllVariants();

    Set<? extends RenderableDependency> getChildren();

    String getDescription();
    List<ResolvedVariantResult> getResolvedVariants();
    List<ResolvedVariantResult> getAllVariants();
    ResolutionState getResolutionState();
    Set<? extends RenderableDependency> getChildren();
    List<Section> getExtraDetails();

    enum ResolutionState {
        FAILED,
        RESOLVED,
        RESOLVED_CONSTRAINT,
        UNRESOLVED
    }

 *
 * <p>If you have your own graph implementation based around a custom node type {@code MyNode},
 * which has a method {@code getChildren()} that retrieves its successors in a graph:
 *
 * <pre>{@code
 * someGraphAlgorithm(startNode, MyNode::getChildren);
 * }</pre>
 *
 * <p>If you have some other mechanism for returning the successors of a node, or one that doesn't

            ? scriptFileResolver
            : new DefaultScriptFileResolver();

        projectDescriptorRegistry.addProject(this);
        if (parent != null) {
            parent.getChildren().add(this);
        }
    }

    private Path path(String name) {
        if (isRootDescriptor()) {
            return path = Path.ROOT;
        } else {
            return parent.absolutePath(name);

 *
 * <p>If you have your own graph implementation based around a custom node type {@code MyNode},
 * which has a method {@code getChildren()} that retrieves its successors in a graph:
 *
 * <pre>{@code
 * someGraphAlgorithm(startNode, MyNode::getChildren);
 * }</pre>
 *
 * <p>If you have some other mechanism for returning the successors of a node, or one that doesn't

    }
}


internal
fun FlyweightCapableTreeStructure<LighterASTNode>.print(
    node: LighterASTNode = root,
    indent: String = ""
) {
    val ref = Ref<Array<LighterASTNode?>>()

    getChildren(node, ref)
    val kidsArray = ref.get() ?: return

    for (kid in kidsArray) {
        if (kid == null) break
        kid.print(indent)
        print(kid, "\t$indent")
    }
}


internal

                               "fallback_disabled", "failure"),
      1);
}

TEST_F(LowerClusterToRuntimeOpsTest, DumpsPipelinePasses) {
  std::vector<std::string> files;
  TF_ASSERT_OK(env_->GetChildren(test_dir_, &files));
  EXPECT_THAT(files, ::testing::IsEmpty());
  setenv("TF_DUMP_GRAPH_NAME_FILTER", "*", /*overwrite=*/1);
  setenv("TF_DUMP_GRAPH_GROUPS", "main,runtime_lowering", /*overwrite=*/1);

        queue.add(runner.getDescription());
        while (!queue.isEmpty()) {
            Description description = queue.removeFirst();
            queue.addAll(description.getChildren());
            if (description.isTest()) {
                notifier.fireTestIgnored(description);
            }
        }
    }

        model.project == null
    }

    def adaptsIterableToDomainObjectSet() {
        TestProtocolModel protocolModel = Mock()
        TestProtocolProject protocolProject = Mock()
        _ * protocolModel.getChildren() >> [protocolProject]
        _ * protocolProject.getName() >> 'name'

        expect:
        def model = adapter.adapt(TestModel.class, protocolModel)
        model.children.size() == 1