/**
     * Adds an action to be executed when a value from a pending element is concretely added.
     * The provided action is only called when a pending value is realized and the value is not
     * already present in the concrete values of this source.
     */
    void onPendingAdded(Action<T> action);

    boolean isEmpty();

    int size();

    void clear();

        return process.inputStream.readLines().drop(3).collect { new File(it).name }
    }

    List<String> listLinkedLibraries() {
        def dumpbin = findExe("dumpbin.exe")
        def process = [dumpbin.absolutePath, '/IMPORTS', binaryFile.absolutePath].execute(["PATH=$vcPath"], null)
        return process.inputStream.readLines()
    }

    List<BinaryInfo.Symbol> listSymbols() {

        assert removeDownloadMessageAndEmptyLines(actualOutput) == expected(expectedOutput)
        return true
    }

    String removeDownloadMessageAndEmptyLines(String output) {
        return output.readLines().findAll { !it.isEmpty() && !(it ==~ /^Download http.*$/) }.join('\n')
    }

    String expected(String normalised) {
        String raw = """------------------------------------------------------------
Root project 'test'

        renderer.completeConfiguration(conf1);
        renderer.startConfiguration(conf2);
        renderer.completeConfiguration(conf2);

        then:
        textOutput.value.readLines() == [
                'config1 - description',
                '',
                'config2 (n)'
        ]
    }

    def "renders dependency graph"() {

	lineReader := &LineReader{reader: reader}

	// read lines
	var readLines [][]byte
	for range lines {
		bytes, err := lineReader.Read()
		if err != nil && err != io.EOF {
			t.Fatalf("failed to read lines: %v", err)
		}
		readLines = append(readLines, bytes)
	}

	// validate
	for i := range lines {
		if len(lines[i]) != len(readLines[i]) {

        def reversedFile = workerExecutorSample(dsl).file("build/reversed/${author}.txt")
        assert reversedFile.exists()
        assert reversedFile.readLines() == workerExecutorSample(dsl).file("sources/${author}.txt").readLines().collect { it.reverse() }
    }

   */
  @CanIgnoreReturnValue // some processors won't return a useful result
  @ParametricNullness
  public static <T extends @Nullable Object> T readLines(
      URL url, Charset charset, LineProcessor<T> callback) throws IOException {
    return asCharSource(url, charset).readLines(callback);
  }

  /**
   * Reads all of the lines from a URL. The lines do not include line-termination characters, but do

        when:
        dsl {
            apply plugin: ComponentBasePlugin
            model {
                baseComponent(ComponentSpec) {
                }
            }
        }

        then:
        realize("baseComponent") instanceof ComponentSpec
    }

    def "adds a 'components' container to the project model"() {
        when:
        dsl {
            apply plugin: ComponentBasePlugin
        }

                            bool smuggle_disallowed_ops);

// This function is a common entry point for all graph optimizations that are
// not specific to any hardware. It legalizes SHLO->MHLO, does MHLO->MHLO
// optimizations by calling `AddMhloOptimizationPasses` internally, and
// legalizes MHLO->SHLO
void AddStablehloOptimizationPasses(OpPassManager& pm);

// Adds all the backend-agonstic stableHLO optimization passes

        dep1.children.addAll(dep11)
        dep2.children.addAll(dep21, dep22)

        when:
        renderer.render([root])
        renderer.complete()

        then:
        textOutput.value.readLines() == [
                '+--- dep1',
                '|    \\--- dep1.1',
                '\\--- dep2',
                '     +--- dep2.1',
                '     \\--- dep2.2'
        ]
    }