// 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}""",

		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) {

        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:

	// File is the source file corresponding to these
	// instructions.
	File *LineFile

	// Line is the source code line number corresponding to these
	// instructions. Lines are numbered beginning at 1. It may be
	// 0 if these instructions cannot be attributed to any source
	// line.
	Line int

	// Column is the column number within the source line of these
	// instructions. Columns are numbered beginning at 1. It may

// 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

	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 {

Andrew Gerrand <******@****.***> 1441330476 +0000

Andrew Gerrand <******@****.***> 1441330476 +0000

// from each line in lines, returning a copy of lines in which
// those prefixes have been trimmed from each line.
// It also replaces any lines containing only spaces with blank lines (empty strings).
func unindent(lines []string) []string {
	// Trim leading and trailing blank lines.
	for len(lines) > 0 && isBlank(lines[0]) {
		lines = lines[1:]
	}
	for len(lines) > 0 && isBlank(lines[len(lines)-1]) {
		lines = lines[:len(lines)-1]
	}