}

    def "returns last line if the limit is one"() {
        given:
        def logFile = log("""\
            line1
            line2
            line3""")

        expect:
        DaemonLogFileUtils.tail(logFile, 1) == "line3"
    }

    def "input-ending eoln is ignored"() {
        given:
        def logFile = log("""\
            line1
            line2
            line3
        """)

            // 6
            """       | Error:              {description}line0{normal}
       |     Caused by:      {description}line1{normal}
       |     Caused by:      {description}line2{normal}
       |     Caused by:      {description}line3{normal}
       |     Caused by:      {description}line4{normal}
       |     Caused by:      {description}line5{normal}
       |                     {description}...{normal}""",

// Returns the buffer position corresponding to the beginning of
// line1 and an error, if any.
func (b *Writer) format(pos0 int, line0, line1 int) (pos int) {
	pos = pos0
	column := len(b.widths)
	for this := line0; this < line1; this++ {
		line := b.lines[this]

		if column >= len(line)-1 {
			continue
		}
		// cell exists in this column => this line
		// has more cells than the previous line

        given:
        def lockFile = lockDir.file('conf.lockfile')
        lockFile << """#Ignored
line1

line2"""

        when:
        def result = lockFileReaderWriter.readLockFile('conf')

        then:
        result == ['line1', 'line2']

        1 * listener.fileObserved(lockFile)
    }

    def 'reads a unique lock file'() {
        given:

			// Valid no update message case. No further
			// validation needed.
			continue
		case !strings.Contains(output, line1):
			t.Errorf("Testcase %d: output '%s' did not contain line 1: '%s'", i+1, output, line1)
		case !strings.Contains(output, line2):
			t.Errorf("Testcase %d: output '%s' did not contain line 2: '%s'", i+1, output, line2)
		}
	}

// the file is number 1, for example. Columns are measured
// in bytes.
// NOTE: This struct is internal to the testing infrastructure and may change.
// It is not covered (yet) by the Go 1 compatibility guidelines.
type CoverBlock struct {
	Line0 uint32 // Line number for block start.
	Col0  uint16 // Column number for block start.
	Line1 uint32 // Line number for block end.

	zfile1C := &LineFile{Name: "/home/iant/go/src/debug/dwarf/testdata/line1.c"}
	zfile2C := &LineFile{Name: "/home/iant/go/src/debug/dwarf/testdata/line2.c"}

	// Line table based on readelf --debug-dump=rawline,decodedline
	want := []LineEntry{
		{Address: 0x401126, File: zfile1H, Line: 2, Column: 1, IsStmt: true},
		{Address: 0x40112a, File: zfile1H, Line: 5, Column: 8, IsStmt: true},

	line := strings.Repeat("12345", 10000)
	r := reader(line + "\r\n")
	s, err := r.ReadLine()
	if err != nil {
		t.Fatalf("Line 1: %v", err)
	}
	if s != line {
		t.Fatalf("%v-byte line does not match expected %v-byte line", len(s), len(line))
	}
}

func TestReadContinuedLine(t *testing.T) {
	r := reader("line1\nline\n 2\nline3\n")
	s, err := r.ReadContinuedLine()
	if s != "line1" || err != nil {

	if err != nil {
		t.Fatal(err)
	}
	// Check the line numbers. Each line is an action containing a template, followed by text.
	// That's two nodes per line.
	nodes := tree.Root.Nodes
	for i := 0; i < len(nodes); i += 2 {
		line := 1 + i/2
		// Action first.
		action := nodes[i].(*ActionNode)
		if action.Line != line {
			t.Errorf("line %d: action is line %d", line, action.Line)
		}
		pipe := action.Pipe

		line:  10,
		want: mkLines(
			LineData{1, "Line1: 1"},
			LineData{2, "Line2: 2"},
			LineData{3, "Line3: 3"},
			LineData{4, "Line4: 4"},
			LineData{5, "Line5: 5"},
			LineData{6, "Line6: 6"},
			LineData{7, "Line7: 7"},
			LineData{8, "Line8: 8"},
			LineData{9, "Line9: 9"},
			LineData{10, "Line10: 10"}),
	}}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {