def expectedContextMsg = PotentialMatch.HEADER + '\n' + contextBody.join('\n')

        then:
        def actualContextMsg = pm.buildContext(2)
        actualContextMsg.readLines() == expectedContextMsg.readLines()

        where:
        expectedLines           | actualLines                               | matchBegins    || contextBody

        // Single Mismatches

    51: 0000000000000000     0 NOTYPE  WEAK   DEFAULT  UND __gmon_start__
    52: 0000000000401090     0 FUNC    GLOBAL DEFAULT  UND _ZNSt8ios_base4I[...]
"""
        def inputLines = input.readLines()
        def symbols = ReadelfBinaryInfo.readSymbols(inputLines)

        then:
        symbols.size() == 4
        symbols*.name.containsAll(['multiply.cpp', 'sum.cpp', 'greeter.cpp', 'main.cpp'])
    }

   * Files#readLines} and {@link Resources#readLines} methods.
   *
   * @param r the object to read from
   * @return a mutable {@link List} containing all the lines
   * @throws IOException if an I/O error occurs
   */
  public static List<String> readLines(Readable r) throws IOException {
    List<String> result = new ArrayList<>();

        if (url == null) {
            throw new IllegalStateException("Could not load default imports resource: " + RESOURCE);
        }
        return Resources.asCharSource(url, Charsets.UTF_8).readLines(new LineProcessor<String[]>() {
            private final List<String> packages = new LinkedList<>();

            @Override

// Create a pass that legalizes MHLO to TF dialect.
std::unique_ptr<OperationPass<ModuleOp>> CreateLegalizeHloToTfPass();

// Creates a pass which replaces a splat constant tensor with a BroadcastInDim
// op.
std::unique_ptr<OperationPass<ModuleOp>> CreateUnfoldSplatConstantPass();

// Create a pass that legalizes MHLO to TFLite dialect.

    std::optional<StringRef> tf2xla_fallback_device_type = std::nullopt,
    bool prefer_tf2xla = false);

// Legalizes TF/XLA communication ops (TF dialect) to HLO dialect communication
// ops.
std::unique_ptr<OperationPass<ModuleOp>> CreateLegalizeTFCommunicationPass();

// Legalizes TF/XLA collective ops (TF dialect) to HLO dialect collective
// ops.
std::unique_ptr<OperationPass<ModuleOp>> CreateLegalizeTFCollectivePass();

        // Configure task through suite
        testing {
            suites {
                test {
                    useJUnitJupiter()
                    targets.all {
                        // explicitly realize the task now to cause this configuration to run now
                        testTask.get().configure {
                            options {
                                includeTags 'fast'
                            }

        dsl {
            apply plugin: TestingModelBasePlugin
            model {
                baseComponent(TestSuiteSpec) {
                }
            }
        }

        then:
        realize("baseComponent") instanceof TestSuiteSpec
    }

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

    TestNameTestDirectoryProvider testDir = new TestNameTestDirectoryProvider(getClass())

    final def project = TestUtil.create(testDir).rootProject()
    @Rule SetRuleContext setContext = new SetRuleContext()

    def realize(String name) {
        project.modelRegistry.find(name, ModelType.UNTYPED)
    }

    ModelMap<Task> realizeTasks() {
        project.modelRegistry.find("tasks", ModelTypes.modelMap(Task))
    }

        def featuresFile = ReleaseFeaturesTest.getClassLoader().getResourceAsStream("release-features.txt")

        when:
        def featuresText = featuresFile.text

        then:
        def lines = featuresText.readLines()
        lines.size() <= 10
        lines.every { it.startsWith(" - ") || it.startsWith("   - ")}
        lines.every { it.length() <= 80 }
    }