;--------------------------------------------------
; Use -strict-whitespace to check marker and note alignment here.
; (Also check multiline marker where start/end columns vary across lines.)
;
; In the remaining checks, don't use -strict-whitespace and thus check just the
; presence, order, and lengths of markers.  That way, if we ever change padding
; within line labels, we don't have to adjust so many tests.
;--------------------------------------------------

; RUN: echo 'hello world' > %t.in
; RUN: echo 'goodbye' >> %t.in
; RUN: echo 'world' >> %t.in
; RUN: echo 'unicorn' >> %t.in

; RUN: echo 'CHECK: hello' > %t.chk
; RUN: echo 'CHECK: universe' >> %t.chk

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
; RUN: | FileCheck -strict-whitespace -match-full-lines -check-prefix=ALIGN \
; RUN:             -implicit-check-not='remark:' %s

; Verbose diagnostics are suppressed but not errors.
; ALIGN:{{.*}}error:{{.*}}
; ALIGN:{{.*}}possible intended match here{{.*}}

; ALIGN:Input was:
; ALIGN-NEXT:<<<<<<
; ALIGN-NEXT:           1: hello world 
; ALIGN-NEXT:check:1       ^~~~~
; ALIGN-NEXT:check:2'0          X~~~~~~ error: no match found
; ALIGN-NEXT:           2: goodbye 
; ALIGN-NEXT:check:2'0     ~~~~~~~~
; ALIGN-NEXT:           3: world 
; ALIGN-NEXT:check:2'0     ~~~~~~
; ALIGN-NEXT:           4: unicorn 
; ALIGN-NEXT:check:2'0     ~~~~~~~~
; ALIGN-NEXT:check:2'1     ?        possible intended match
; ALIGN-NEXT:>>>>>>
; ALIGN-NOT:{{.}}

;--------------------------------------------------
; CHECK (also: multi-line search range, fuzzy match)
;--------------------------------------------------

; Good match and no match.

; RUN: echo 'hello'   > %t.in
; RUN: echo 'again'   >> %t.in
; RUN: echo 'whirled' >> %t.in

; RUN: echo 'CHECK: hello' > %t.chk
; RUN: echo 'CHECK: world' >> %t.chk

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefix=CHK \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=CHK,CHK-V \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=CHK,CHK-V \
; RUN:             -implicit-check-not='remark:'

; Verbose diagnostics are suppressed but not errors.
; CHK: {{.*}}error:{{.*}}
; CHK: {{.*}}possible intended match here{{.*}}

; CHK:        <<<<<<
; CHK-NEXT:              1: hello 
; CHK-V-NEXT: check:1       ^~~~~
; CHK-NEXT:   check:2'0          X error: no match found
; CHK-NEXT:              2: again 
; CHK-NEXT:   check:2'0     ~~~~~~
; CHK-NEXT:              3: whirled 
; CHK-NEXT:   check:2'0     ~~~~~~~~
; CHK-NEXT:   check:2'1     ?        possible intended match
; CHK-NEXT:   >>>>>>
; CHK-NOT:    {{.}}

;--------------------------------------------------
; CHECK-COUNT-<num>
;--------------------------------------------------

; Good match and no match.

; RUN: echo 'pete'   > %t.in
; RUN: echo 'repete' >> %t.in
; RUN: echo 'repeat' >> %t.in

; RUN: echo 'CHECK-COUNT-3: pete' > %t.chk

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=CNT,CNT-Q \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=CNT,CNT-V \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=CNT,CNT-V \
; RUN:             -implicit-check-not='remark:'

; Verbose diagnostics are suppressed but not errors.
; CNT: {{.*}}error:{{.*}}

; CNT:          <<<<<<
; CNT-NEXT:                1: pete 
; CNT-V-NEXT:   count:1'0     ^~~~
; CNT-NEXT:                2: repete 
; CNT-V-NEXT:   count:1'1       ^~~~
; CNT-Q-NEXT:   count:1'0           X error: no match found
; CNT-V-NEXT:   count:1'2           X error: no match found
; CNT-NEXT:                3: repeat 
; CNT-Q-NEXT:   count:1'0     ~~~~~~~
; CNT-Q-NEXT:   count:1'1     ?       possible intended match
; CNT-V-NEXT:   count:1'2     ~~~~~~~
; CNT-V-NEXT:   count:1'3     ?       possible intended match
; CNT-NEXT:     >>>>>>
; CNT-NOT:      {{.}}

;--------------------------------------------------
; CHECK-NEXT (also: EOF search-range, wrong-line match)
;--------------------------------------------------

; Good match and no match.

; RUN: echo 'hello' > %t.in
; RUN: echo 'again' >> %t.in

; RUN: echo 'CHECK: hello' > %t.chk
; RUN: echo 'CHECK-NEXT: again' >> %t.chk
; RUN: echo 'CHECK-NEXT: world' >> %t.chk

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefix=NXT \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=NXT,NXT-V \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=NXT,NXT-V,NXT-VV \
; RUN:             -implicit-check-not='remark:' -allow-unused-prefixes

; Verbose diagnostics are suppressed but not errors.
; NXT: {{.*}}error:{{.*}}

; NXT:        <<<<<<
; NXT-NEXT:            1: hello 
; NXT-V-NEXT: check:1     ^~~~~
; NXT-NEXT:            2: again 
; NXT-V-NEXT: next:2      ^~~~~
; NXT-NEXT:   next:3           X error: no match found
; NXT-NEXT:   >>>>>>
; NXT-NOT:    {{.}}

; Wrong-line match.

; RUN: echo 'yonder' >> %t.in
; RUN: echo 'world' >> %t.in

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefix=NXT2

; NXT2:      <<<<<<
; NXT2-NEXT:         1: hello 
; NXT2-NEXT:         2: again 
; NXT2-NEXT:         3: yonder 
; NXT2-NEXT:         4: world 
; NXT2-NEXT: next:3     !~~~~  error: match on wrong line
; NXT2-NEXT: >>>>>>
; NXT2-NOT:  {{.}}

;--------------------------------------------------
; CHECK-SAME (also: multiple annotations per line, single-char search range,
; wrong-line match)
;--------------------------------------------------

; Good match and no match.

; RUN: echo 'hello world!' > %t.in

; RUN: echo 'CHECK: hello' > %t.chk
; RUN: echo 'CHECK-SAME: world' >> %t.chk
; RUN: echo 'CHECK-SAME: again' >> %t.chk

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefix=SAM \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=SAM,SAM-V \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=SAM,SAM-V,SAM-VV \
; RUN:             -implicit-check-not='remark:' -allow-unused-prefixes

; Verbose diagnostics are suppressed but not errors.
; SAM: {{.*}}error:{{.*}}

; SAM:        <<<<<<
; SAM-NEXT:            1: hello world! 
; SAM-V-NEXT: check:1     ^~~~~
; SAM-V-NEXT: same:2            ^~~~~
; SAM-NEXT:   same:3                 X~ error: no match found
; SAM-NEXT:   >>>>>>
; SAM-NOT:    {{.}}

; Wrong-line match.

; RUN: echo 'again' >> %t.in

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=SAM2 \
; RUN:             -implicit-check-not='remark:'

; Verbose diagnostics are suppressed but not errors.
; SAM2: {{.*}}error:{{.*}}

; SAM2:      <<<<<<
; SAM2-NEXT:          1: hello world! 
; SAM2-NEXT: check:1     ^~~~~
; SAM2-NEXT: same:2            ^~~~~
; SAM2-NEXT:          2: again 
; SAM2-NEXT: same:3      !~~~~  error: match on wrong line
; SAM2-NEXT: >>>>>>
; SAM2-NOT:  {{.}}

;--------------------------------------------------
; CHECK-EMPTY (also: search range ends at label, single-char match, wrong-line
; match)
;--------------------------------------------------

; Good match and no match.
;
; CHECK-EMPTY always seems to match an empty line at EOF (illegally when it's
; not the next line) unless either (1) the last line is non-empty and has no
; newline or (2) there's a CHECK-LABEL to end the search range before EOF.  We
; choose scenario 2 to check the case of no match.

; RUN: echo 'hello' > %t.in
; RUN: echo '' >> %t.in
; RUN: echo 'world' >> %t.in
; RUN: echo 'label' >> %t.in

; RUN: echo 'CHECK: hello' > %t.chk
; RUN: echo 'CHECK-EMPTY:' >> %t.chk
; RUN: echo 'CHECK-EMPTY:' >> %t.chk
; RUN: echo 'CHECK-LABEL: label' >> %t.chk

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefix=EMP \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=EMP,EMP-V \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=EMP,EMP-V,EMP-VV \
; RUN:             -implicit-check-not='remark:' -allow-unused-prefixes

; Verbose diagnostics are suppressed but not errors.
; EMP: {{.*}}error:{{.*}}

; EMP:        <<<<<<
; EMP-NEXT:            1: hello 
; EMP-V-NEXT: check:1     ^~~~~
; EMP-NEXT:            2:
; EMP-V-NEXT: empty:2     ^
; EMP-NEXT:   empty:3          X error: no match found
; EMP-NEXT:            3: world 
; EMP-NEXT:   empty:3     ~~~~~~
; EMP-NEXT:            4: label 
; EMP-V-NEXT: label:4     ^~~~~
; EMP-NEXT:   empty:3     ~~~~~
; EMP-NEXT:   >>>>>>
; EMP-NOT:    {{.}}

; Wrong-line match.

; RUN: echo 'hello' > %t.in
; RUN: echo 'world' >> %t.in

; RUN: echo 'CHECK: hello' > %t.chk
; RUN: echo 'CHECK-EMPTY:' >> %t.chk

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefix=EMP2 \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=EMP2,EMP2-V \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=EMP2,EMP2-V,EMP2-VV \
; RUN:             -implicit-check-not='remark:' -allow-unused-prefixes

; Verbose diagnostics are suppressed but not errors.
; EMP2: {{.*}}error:{{.*}}

; EMP2:        <<<<<<
; EMP2-NEXT:            1: hello 
; EMP2-V-NEXT: check:1     ^~~~~
; EMP2-NEXT:            2: world 
; EMP2-NEXT:            3:
; EMP2-NEXT:   empty:2     !      error: match on wrong line
; EMP2-NEXT:   >>>>>>
; EMP2-NOT:    {{.}}

;--------------------------------------------------
; CHECK-NOT (also: EOF pattern, and multiline range that ends before EOL)
;--------------------------------------------------

; No match (success) and unexpected match (error).

; RUN: echo 'hello' > %t.in
; RUN: echo 'world' >> %t.in
; RUN: echo 'again' >> %t.in

; RUN: echo 'CHECK-NOT: goodbye' > %t.chk
; RUN: echo 'CHECK-NOT: world' >> %t.chk

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefix=NOT \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=NOT,NOT-V \
; RUN:             -implicit-check-not='remark:' -allow-unused-prefixes
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=NOT,NOT-V,NOT-VV \
; RUN:             -implicit-check-not='remark:' -allow-unused-prefixes

; Verbose diagnostics are suppressed but not errors.
; NOT: {{.*}}error:{{.*}}

; NOT:         <<<<<<
; NOT-NEXT:           1: hello 
; NOT-VV-NEXT: not:1     X~~~~~
; NOT-NEXT:           2: world 
; NOT-VV-NEXT: not:1     ~~~~~~
; NOT-NEXT:    not:2     !~~~~  error: no match expected
; NOT-NEXT:           3: again 
; NOT-VV-NEXT: not:1     ~~~~~~
; NOT-VV-NEXT:        4:
; NOT-VV-NEXT: eof:2     ^
; NOT-NEXT:    >>>>>>
; NOT-NOT:     {{.}}

; Again, but with a CHECK instead of EOF as search range end.

; RUN: echo 'CHECK: ain' >> %t.chk

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefix=NOT2 \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=NOT2,NOT2-V \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=NOT2,NOT2-V,NOT2-VV \
; RUN:             -implicit-check-not='remark:'

; Verbose diagnostics are suppressed but not errors.
; NOT2: {{.*}}error:{{.*}}

; NOT2:         <<<<<<
; NOT2-NEXT:             1: hello 
; NOT2-VV-NEXT: not:1       X~~~~~
; NOT2-NEXT:             2: world 
; NOT2-VV-NEXT: not:1       ~~~~~~
; NOT2-NEXT:    not:2       !~~~~  error: no match expected
; NOT2-NEXT:             3: again 
; NOT2-V-NEXT:  check:3       ^~~
; NOT2-VV-NEXT: not:1       ~~
; NOT2-NEXT:    >>>>>>
; NOT2-NOT:     {{.}}

;--------------------------------------------------
; CHECK-DAG (also: matches in different order than directives, discarded match)
;--------------------------------------------------

; Good match, discarded match plus good match, and no match.

; RUN: echo 'abc' > %t.in
; RUN: echo 'def' >> %t.in
; RUN: echo 'abc' >> %t.in

; RUN: echo 'CHECK-DAG: def' > %t.chk
; RUN: echo 'CHECK-DAG: abc' >> %t.chk
; RUN: echo 'CHECK-DAG: abc' >> %t.chk
; RUN: echo 'CHECK-DAG: def' >> %t.chk

; Prefixes used here:
; DAG    = quiet, -v, or -vv
; DAG-Q  = quiet
; DAG-V  = -v or -vv (-vv implies -v)
; DAG-VQ = -v and not -vv
; DAG-VV = -vv

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=DAG,DAG-Q \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=DAG,DAG-V,DAG-VQ \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=DAG,DAG-V,DAG-VV \
; RUN:             -implicit-check-not='remark:'

; Verbose diagnostics are suppressed but not errors.
; DAG: {{.*}}error:{{.*}}

; DAG:         <<<<<<
; DAG-NEXT:             1: abc 
; DAG-V-NEXT:  dag:2       ^~~
; DAG-VV-NEXT: dag:3'0     !~~  discard: overlaps earlier match
; DAG-NEXT:             2: def 
; DAG-V-NEXT:  dag:1       ^~~
; DAG-VV-NEXT: dag:4'0     !~~  discard: overlaps earlier match
; DAG-Q-NEXT:  dag:4          X error: no match found
; DAG-VQ-NEXT: dag:4          X error: no match found
; DAG-VV-NEXT: dag:4'1        X error: no match found
; DAG-NEXT:             3: abc 
; DAG-VQ-NEXT: dag:3       ^~~
; DAG-VV-NEXT: dag:3'1     ^~~
; DAG-Q-NEXT:  dag:4       ~~~~
; DAG-VQ-NEXT: dag:4       ~~~~
; DAG-VV-NEXT: dag:4'1     ~~~~
; DAG-NEXT:    >>>>>>
; DAG-NOT:     {{.}}

; Check sorting of annotations when the order of diagnostics across an input
; line is different than the order of the associated directives in the check
; file.  Try cases when diagnostics' input ranges overlap but are not
; identical to check how that affects sorting.

; RUN: echo 'abc def abc def' > %t.in

; RUN: echo 'CHECK-DAG: def' > %t.chk
; RUN: echo 'CHECK-DAG: bc' >> %t.chk
; RUN: echo 'CHECK-DAG: abc' >> %t.chk
; RUN: echo 'CHECK-DAG: de' >> %t.chk
; RUN: echo 'CHECK-DAG: def' >> %t.chk

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=DAG1L,DAG1L-Q \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=DAG1L,DAG1L-V,DAG1L-VQ \
; RUN:             -implicit-check-not='remark:'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=DAG1L,DAG1L-V,DAG1L-VV \
; RUN:             -implicit-check-not='remark:'

; Verbose diagnostics are suppressed but not errors.
; DAG1L:{{.*}}error:{{.*}}

;         DAG1L:<<<<<<
;    DAG1L-NEXT:         1: abc def abc def 
;  DAG1L-V-NEXT:dag:1           ^~~
;  DAG1L-V-NEXT:dag:2        ^~
; DAG1L-VV-NEXT:dag:3'0     !~~              discard: overlaps earlier match
; DAG1L-VQ-NEXT:dag:3               ^~~
; DAG1L-VV-NEXT:dag:3'1             ^~~
; DAG1L-VV-NEXT:dag:4'0         !~           discard: overlaps earlier match
; DAG1L-VQ-NEXT:dag:4                   ^~
; DAG1L-VV-NEXT:dag:4'1                 ^~
; DAG1L-VV-NEXT:dag:5'0         !~~          discard: overlaps earlier match
; DAG1L-VV-NEXT:dag:5'1                 !~~  discard: overlaps earlier match
;  DAG1L-Q-NEXT:dag:5                     X~ error: no match found
; DAG1L-VQ-NEXT:dag:5                     X~ error: no match found
; DAG1L-VV-NEXT:dag:5'2                   X~ error: no match found
;    DAG1L-NEXT:>>>>>>
;     DAG1L-NOT:{{.}}

;--------------------------------------------------
; CHECK-LABEL
;
; Each CHECK-LABEL is processed twice: once before other patterns in the
; preceding section, and once afterward.
;
; As expected, the search range for a negative pattern preceding a CHECK-LABEL
; ends at the start of the CHECK-LABEL match.  not:7 and not:11 below
; demonstrate this behavior.
;
; The search range for a positive pattern preceding a CHECK-LABEL ends at the
; end of the CHECK-LABEL match.  check:3 and check:5 below demonstrate this
; behavior.  As in the case of check:5, an effect of this behavior is that the
; second CHECK-LABEL match might fail even though the first succeeded.
;
; FIXME: It seems like the search range for such a positive pattern should be
; the same as in the case of a negative pattern.  Note that -dump-input is
; correct here.  It's the matching behavior that's strange.
;--------------------------------------------------

; RUN: echo 'text'   >  %t.in
; RUN: echo 'labelA' >> %t.in
; RUN: echo 'textA'  >> %t.in
; RUN: echo 'labelB' >> %t.in
; RUN: echo 'textB'  >> %t.in
; RUN: echo 'labelC' >> %t.in
; RUN: echo 'textC'  >> %t.in
; RUN: echo 'labelD' >> %t.in
; RUN: echo 'textD'  >> %t.in
; RUN: echo 'labelE' >> %t.in
; RUN: echo 'textE'  >> %t.in
; RUN: echo 'labelF' >> %t.in

; RUN: echo 'CHECK: text'         >  %t.chk
; RUN: echo 'CHECK-LABEL: labelA' >> %t.chk
; RUN: echo 'CHECK: foobar'       >> %t.chk
; RUN: echo 'CHECK-LABEL: labelB' >> %t.chk
; RUN: echo 'CHECK: labelC'       >> %t.chk
; RUN: echo 'CHECK-LABEL: labelC' >> %t.chk
; RUN: echo 'CHECK-NOT: foobar'   >> %t.chk
; RUN: echo 'CHECK-LABEL: labelD' >> %t.chk
; RUN: echo 'CHECK-NOT: textD'    >> %t.chk
; RUN: echo 'CHECK-LABEL: labelE' >> %t.chk
; RUN: echo 'CHECK-NOT: labelF'   >> %t.chk
; RUN: echo 'CHECK-LABEL: labelF' >> %t.chk

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=LAB,LAB-Q \
; RUN:             -implicit-check-not='{{remark:|error:}}'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -v 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=LAB,LAB-V \
; RUN:             -implicit-check-not='{{remark:|error:}}'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file %t.in %t.chk -vv 2>&1 \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=LAB,LAB-V,LAB-VV \
; RUN:             -implicit-check-not='{{remark:|error:}}'

; Verbose diagnostics are suppressed but not errors.
; LAB:{{.*}}.chk:3:8: error: CHECK: expected string not found in input
; LAB:{{.*}}.chk:6:14: error: CHECK-LABEL: expected string not found in input
; LAB:{{.*}}.chk:9:12: error: CHECK-NOT: excluded string found in input

;         LAB:<<<<<<
;    LAB-NEXT:            1: text 
;  LAB-V-NEXT:check:1        ^~~~
;    LAB-NEXT:            2: labelA 
;  LAB-V-NEXT:label:2'0      ^~~~~~
;  LAB-V-NEXT:label:2'1      ^~~~~~
;    LAB-NEXT:check:3              X error: no match found
;    LAB-NEXT:            3: textA 
;    LAB-NEXT:check:3        ~~~~~~
;    LAB-NEXT:            4: labelB 
;  LAB-V-NEXT:label:4        ^~~~~~
;    LAB-NEXT:check:3        ~~~~~~
;    LAB-NEXT:            5: textB 
;    LAB-NEXT:            6: labelC 
;  LAB-V-NEXT:label:6'0      ^~~~~~
;  LAB-V-NEXT:check:5        ^~~~~~
;  LAB-Q-NEXT:label:6              X error: no match found
;  LAB-V-NEXT:label:6'1            X error: no match found
; LAB-VV-NEXT:not:7                X
;    LAB-NEXT:            7: textC 
; LAB-VV-NEXT:not:7          ~~~~~~
;    LAB-NEXT:            8: labelD 
;  LAB-V-NEXT:label:8'0      ^~~~~~
;  LAB-V-NEXT:label:8'1      ^~~~~~
;    LAB-NEXT:            9: textD 
;    LAB-NEXT:not:9          !~~~~  error: no match expected
;    LAB-NEXT:           10: labelE 
;  LAB-V-NEXT:label:10'0     ^~~~~~
;  LAB-V-NEXT:label:10'1     ^~~~~~
; LAB-VV-NEXT:not:11               X
;    LAB-NEXT:           11: textE 
; LAB-VV-NEXT:not:11         ~~~~~~
;    LAB-NEXT:           12: labelF 
;  LAB-V-NEXT:label:12'0     ^~~~~~
;  LAB-V-NEXT:label:12'1     ^~~~~~
;    LAB-NEXT:>>>>>>
;     LAB-NOT:{{.}}

;--------------------------------------------------
; --implicit-check-not
;
; The first two --implicit-check-not patterns have no match (success).  The
; third has an unexpected match (error).  To check per-input-line annotation
; sorting, all of those plus the CHECK directives have annotations on the same
; input line.
;--------------------------------------------------

; RUN: echo 'hello world again!' > %t.in

; RUN: echo 'CHECK: hel' > %t.chk
; RUN: echo 'CHECK: wor' >> %t.chk
; RUN: echo 'CHECK: !' >> %t.chk

; Prefixes used here:
; IMPNOT    = quiet, -v, or -vv
; IMPNOT-Q  = quiet
; IMPNOT-V  = -v or -vv (-vv implies -v)
; IMPNOT-VQ = -v and not -vv
; IMPNOT-VV = -vv

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file=%t.in %t.chk 2>&1 \
; RUN:               --implicit-check-not='goodbye' \
; RUN:               --implicit-check-not='world' \
; RUN:               --implicit-check-not='again' \
; RUN: | FileCheck -match-full-lines %s -check-prefixes=IMPNOT,IMPNOT-Q \
; RUN:             -implicit-check-not='{{remark:|error:}}'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file=%t.in %t.chk -v 2>&1 \
; RUN:               --implicit-check-not='goodbye' \
; RUN:               --implicit-check-not='world' \
; RUN:               --implicit-check-not='again' \
; RUN: | FileCheck -match-full-lines %s \
; RUN:             -check-prefixes=IMPNOT,IMPNOT-V,IMPNOT-VQ \
; RUN:             -implicit-check-not='{{remark:|error:}}'
; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -input-file=%t.in %t.chk -vv 2>&1 \
; RUN:               --implicit-check-not='goodbye' \
; RUN:               --implicit-check-not='world' \
; RUN:               --implicit-check-not='again' \
; RUN: | FileCheck -match-full-lines %s \
; RUN:             -check-prefixes=IMPNOT,IMPNOT-V,IMPNOT-VV \
; RUN:             -implicit-check-not='{{remark:|error:}}'

; Verbose diagnostics are suppressed but not errors.
; IMPNOT:{{.*}}command line:1:22: error: CHECK-NOT: excluded string found in input

;         IMPNOT:<<<<<<
;    IMPNOT-NEXT:            1: hello world again! 
;  IMPNOT-V-NEXT:check:1        ^~~
; IMPNOT-VV-NEXT:not:imp1'0     X
; IMPNOT-VV-NEXT:not:imp2'0     X
; IMPNOT-VV-NEXT:not:imp3'0     X
;  IMPNOT-V-NEXT:check:2              ^~~
; IMPNOT-VV-NEXT:not:imp1'1        X~~
; IMPNOT-VV-NEXT:not:imp2'1        X~~
; IMPNOT-VV-NEXT:not:imp3'1        X~~
;  IMPNOT-V-NEXT:check:3                         ^
; IMPNOT-VV-NEXT:not:imp1'2              X~~~~~~~
; IMPNOT-VV-NEXT:not:imp2'2              X~~~~~~~
;  IMPNOT-Q-NEXT:not:imp3                   !~~~~   error: no match expected
; IMPNOT-VQ-NEXT:not:imp3                   !~~~~   error: no match expected
; IMPNOT-VV-NEXT:not:imp3'2                 !~~~~   error: no match expected
;    IMPNOT-NEXT:>>>>>>
;     IMPNOT-NOT:{{.}}

;--------------------------------------------------
; Substitutions: successful and failed positive directives.
;--------------------------------------------------

; RUN: echo 'def-match1 def-match2'  >  %t.in
; RUN: echo 'def-match1 def-nomatch' >> %t.in

; RUN: echo 'CHECK: [[DEF_MATCH1]] [[DEF_MATCH2]]'            >  %t.chk
; RUN: echo 'CHECK: [[DEF_MATCH1]] [[UNDEF]] [[DEF_NOMATCH]]' >> %t.chk

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -vv -input-file=%t.in %t.chk 2>&1 \
; RUN:               -DDEF_MATCH1=def-match1 -DDEF_MATCH2=def-match2 \
; RUN:               -DDEF_NOMATCH=foobar \
; RUN: | FileCheck -match-full-lines %s -check-prefix=SUBST-POS

;      SUBST-POS:<<<<<<
; SUBST-POS-NEXT:           1: def-match1 def-match2 
; SUBST-POS-NEXT:check:1'0     ^~~~~~~~~~~~~~~~~~~~~
; SUBST-POS-NEXT:check:1'1                            with "DEF_MATCH1" equal to "def-match1"
; SUBST-POS-NEXT:check:1'2                            with "DEF_MATCH2" equal to "def-match2"
; SUBST-POS-NEXT:check:2'0     X error: match failed for invalid pattern
; SUBST-POS-NEXT:check:2'1                            undefined variable: UNDEF
; SUBST-POS-NEXT:check:2'2                            with "DEF_MATCH1" equal to "def-match1"
; SUBST-POS-NEXT:check:2'3                            with "DEF_NOMATCH" equal to "foobar"
; SUBST-POS-NEXT:           2: def-match1 def-nomatch
; SUBST-POS-NEXT:check:2'0     ~~~~~~~~~~~~~~~~~~~~~~~
; SUBST-POS-NEXT:check:2'4 ? possible intended match
; SUBST-POS-NEXT:>>>>>>

;--------------------------------------------------
; Substitutions: successful and failed negative directives.
;--------------------------------------------------

; RUN: echo 'def-match1 def-nomatch' >  %t.in
; RUN: echo 'def-match1 def-match2'  >> %t.in
; RUN: echo 'END'                    >> %t.in

; RUN: echo 'CHECK-NOT: [[DEF_MATCH1]] [[UNDEF]] [[DEF_NOMATCH]]' >  %t.chk
; RUN: echo 'CHECK-NOT: [[DEF_MATCH1]] [[DEF_MATCH2]]'            >> %t.chk
; RUN: echo 'CHECK: END'                                          >> %t.chk

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -vv -input-file=%t.in %t.chk 2>&1 \
; RUN:               -DDEF_MATCH1=def-match1 -DDEF_MATCH2=def-match2 \
; RUN:               -DDEF_NOMATCH=foobar \
; RUN: | FileCheck -match-full-lines %s -check-prefix=SUBST-NEG

;      SUBST-NEG:<<<<<<
; SUBST-NEG-NEXT:         1: def-match1 def-nomatch
; SUBST-NEG-NEXT:not:1'0     X~~~~~~~~~~~~~~~~~~~~~~ error: match failed for invalid pattern
; SUBST-NEG-NEXT:not:1'1                             undefined variable: UNDEF
; SUBST-NEG-NEXT:not:1'2                             with "DEF_MATCH1" equal to "def-match1"
; SUBST-NEG-NEXT:not:1'3                             with "DEF_NOMATCH" equal to "foobar"
; SUBST-NEG-NEXT:         2: def-match1 def-match2
; SUBST-NEG-NEXT:not:1'0     ~~~~~~~~~~~~~~~~~~~~~~
; SUBST-NEG-NEXT:not:2'0     !~~~~~~~~~~~~~~~~~~~~  error: no match expected
; SUBST-NEG-NEXT:not:2'1                            with "DEF_MATCH1" equal to "def-match1"
; SUBST-NEG-NEXT:not:2'2                            with "DEF_MATCH2" equal to "def-match2"
; SUBST-NEG-NEXT:         3: END
; SUBST-NEG-NEXT:check:3     ^~~
; SUBST-NEG-NEXT:>>>>>>

;--------------------------------------------------
; Captured variables
;--------------------------------------------------

; RUN: echo 'strvar: foo'           >  %t.in
; RUN: echo 'numvar no expr: 51'    >> %t.in
; RUN: echo 'numvar expr: -49'      >> %t.in
; RUN: echo 'many: foo 100 8 bar'   >> %t.in
; RUN: echo 'var in neg match: foo' >> %t.in
; RUN: echo 'END'                   >> %t.in

; RUN: echo 'CHECK: strvar: [[STRVAR:[a-z]+]]'                         >  %t.chk
; RUN: echo 'CHECK: numvar no expr: [[#NUMVAR_NO_EXPR:]]'              >> %t.chk
; RUN: echo 'CHECK: numvar expr: [[#%d,NUMVAR_EXPR:2-NUMVAR_NO_EXPR]]' >> %t.chk

; Capture many variables of different kinds in a different order than their
; names sort alphabetically to ensure they're sorted in capture order.
; RUN: echo 'CHECK: many: [[VAR1:foo]] [[#%d,VAR3:]] [[#VAR2:]] [[VAR4:bar]]' \
; RUN:      >> %t.chk

; RUN: echo 'CHECK-NOT: var in neg match: [[VAR:foo]]' >> %t.chk
; RUN: echo 'CHECK: END'                               >> %t.chk

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -vv -input-file=%t.in %t.chk 2>&1 \
; RUN: | FileCheck -strict-whitespace -match-full-lines %s -check-prefix=CAPTURE-NEG

;      CAPTURE-NEG:<<<<<<
; CAPTURE-NEG-NEXT:           1: strvar: foo 
; CAPTURE-NEG-NEXT:check:1'0     ^~~~~~~~~~~
; CAPTURE-NEG-NEXT:check:1'1             ^~~  captured var "STRVAR"
; CAPTURE-NEG-NEXT:           2: numvar no expr: 51 
; CAPTURE-NEG-NEXT:check:2'0     ^~~~~~~~~~~~~~~~~~
; CAPTURE-NEG-NEXT:check:2'1                     ^~  captured var "NUMVAR_NO_EXPR"
; CAPTURE-NEG-NEXT:           3: numvar expr: -49 
; CAPTURE-NEG-NEXT:check:3'0     ^~~~~~~~~~~~~~~~
; CAPTURE-NEG-NEXT:check:3'1                       with "%d,NUMVAR_EXPR:2-NUMVAR_NO_EXPR" equal to "-49"
; CAPTURE-NEG-NEXT:check:3'2                  ^~~  captured var "NUMVAR_EXPR"
; CAPTURE-NEG-NEXT:           4: many: foo 100 8 bar 
; CAPTURE-NEG-NEXT:check:4'0     ^~~~~~~~~~~~~~~~~~~
; CAPTURE-NEG-NEXT:check:4'1           ^~~            captured var "VAR1"
; CAPTURE-NEG-NEXT:check:4'2               ^~~        captured var "VAR3"
; CAPTURE-NEG-NEXT:check:4'3                   ^      captured var "VAR2"
; CAPTURE-NEG-NEXT:check:4'4                     ^~~  captured var "VAR4"
; CAPTURE-NEG-NEXT:           5: var in neg match: foo 
; CAPTURE-NEG-NEXT:not:5'0       !~~~~~~~~~~~~~~~~~~~~  error: no match expected
; CAPTURE-NEG-NEXT:not:5'1                         !~~  captured var "VAR"
; CAPTURE-NEG-NEXT:           6: END 
; CAPTURE-NEG-NEXT:check:6       ^~~
; CAPTURE-NEG-NEXT:>>>>>>

;--------------------------------------------------
; CHECK-NEXT, CHECK-SAME, CHECK-DAG note fixups.
;
; When CHECK-NEXT or CHECK-SAME fails for the wrong line, or when a CHECK-DAG
; match is discarded, the associated diagnostic type must be converted from
; successful to failed or discarded.  However, any note annotation must be
; traversed to find that diagnostic.  We check this behavior here only for
; substitutions, but it's the same mechanism for all note annotations.
;--------------------------------------------------

;- - - - - - - - - - - - - - - - - - - - - - - - -
; CHECK-NEXT.
;- - - - - - - - - - - - - - - - - - - - - - - - -

; RUN: echo 'pre var' > %t.in

; RUN: echo 'CHECK: pre'          >  %t.chk
; RUN: echo 'CHECK-NEXT: [[VAR]]' >> %t.chk

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -vv -input-file=%t.in %t.chk 2>&1 \
; RUN:               -DVAR=var \
; RUN: | FileCheck -match-full-lines %s -check-prefix=SUBST_NEXT

;      SUBST_NEXT:<<<<<<
; SUBST_NEXT-NEXT:          1: pre var 
; SUBST_NEXT-NEXT:check:1      ^~~
; SUBST_NEXT-NEXT:next:2'0         !~~  error: match on wrong line
; SUBST_NEXT-NEXT:next:2'1              with "VAR" equal to "var"
; SUBST_NEXT-NEXT:>>>>>>

;- - - - - - - - - - - - - - - - - - - - - - - - -
; CHECK-SAME.
;- - - - - - - - - - - - - - - - - - - - - - - - -

; RUN: echo 'pre' >  %t.in
; RUN: echo 'var' >> %t.in

; RUN: echo 'CHECK: pre'          >  %t.chk
; RUN: echo 'CHECK-SAME: [[VAR]]' >> %t.chk

; RUN: %ProtectFileCheckOutput \
; RUN: not FileCheck -dump-input=always -vv -input-file=%t.in %t.chk 2>&1 \
; RUN:               -DVAR=var \
; RUN: | FileCheck -match-full-lines %s -check-prefix=SUBST_SAME

;      SUBST_SAME:<<<<<<
; SUBST_SAME-NEXT:          1: pre 
; SUBST_SAME-NEXT:check:1      ^~~
; SUBST_SAME-NEXT:          2: var 
; SUBST_SAME-NEXT:same:2'0     !~~  error: match on wrong line
; SUBST_SAME-NEXT:same:2'1          with "VAR" equal to "var"
; SUBST_SAME-NEXT:>>>>>>

;- - - - - - - - - - - - - - - - - - - - - - - - -
; CHECK-DAG.
;- - - - - - - - - - - - - - - - - - - - - - - - -

; RUN: echo 'var' >  %t.in
; RUN: echo 'var' >> %t.in
; RUN: echo 'END' >> %t.in

; RUN: echo 'CHECK-DAG: var'      >  %t.chk
; RUN: echo 'CHECK-DAG: [[VAR]]'  >> %t.chk
; RUN: echo 'CHECK: END'          >> %t.chk

; RUN: %ProtectFileCheckOutput \
; RUN: FileCheck -dump-input=always -vv -input-file=%t.in %t.chk 2>&1 \
; RUN:           -DVAR=var \
; RUN: | FileCheck -match-full-lines %s -check-prefix=SUBST_DAG

;      SUBST_DAG:<<<<<<
; SUBST_DAG-NEXT:         1: var 
; SUBST_DAG-NEXT:dag:1       ^~~
; SUBST_DAG-NEXT:dag:2'0     !~~  discard: overlaps earlier match
; SUBST_DAG-NEXT:dag:2'1          with "VAR" equal to "var"
; SUBST_DAG-NEXT:         2: var 
; SUBST_DAG-NEXT:dag:2'2     ^~~
; SUBST_DAG-NEXT:dag:2'3          with "VAR" equal to "var"
; SUBST_DAG-NEXT:         3: END 
; SUBST_DAG-NEXT:check:3     ^~~
; SUBST_DAG-NEXT:>>>>>>