; Throughout this file, where %{pre}=FOO, FileCheck prefixes are as follows to ; indicate the level of FileCheck verbosity under test: ; - FOO = quiet, -v, or -vv ; - FOO-V = -v or -vv (-vv implies -v) ; - FOO-VV = -vv ; - FOO-Q = quiet only ; - FOO-VQ = -v only ; ; Most cases use just FOO, FOO-V, and FOO-VV in a unified block of directives ; that checks an input dump where some annotations are omitted at lower ; verbosity levels. ; ; For a few cases, multiple annotations persist but *change* across verbosity ; levels, usually due to modified annotation labels. Seeing multiple versions ; of the same annotation in the same block of directives can be confusing. To ; improve readability, it is usually best to split these into separate blocks. ; For example, use FOO-Q to check only the version without -v or -vv. ; DEFINE: %{pre} = ; DEFINE: %{opts} = ; ; DEFINE: %{run-fc} = \ ; DEFINE: %ProtectFileCheckOutput \ ; DEFINE: FileCheck -dump-input=always -input-file=%t.in %t.chk \ ; DEFINE: -dump-input-label-width=15 %{opts} ; ; DEFINE: %{check-fc} = \ ; DEFINE: FileCheck -strict-whitespace -match-full-lines %s \ ; DEFINE: -allow-unused-prefixes \ ; DEFINE: -implicit-check-not='remark:' -implicit-check-not='error:' ; ; For each case, it is usually best to run these in order of decreasing ; verbosity to maximize the information for debugging when the case is broken. ; ; DEFINE: %{run-vv} = %{run-fc} -vv 2>&1 | \ ; DEFINE: %{check-fc} -check-prefixes=%{pre},%{pre}-V,%{pre}-VV ; DEFINE: %{run-v} = %{run-fc} -v 2>&1 | \ ; DEFINE: %{check-fc} -check-prefixes=%{pre},%{pre}-V,%{pre}-VQ ; DEFINE: %{run} = %{run-fc} 2>&1 | \ ; DEFINE: %{check-fc} -check-prefixes=%{pre},%{pre}-Q ;-------------------------------------------------- ; Label column width ; ; Check that the label column width is sane when we do not force a minimum. The ; rest of the test file is easier to maintain if we otherwise always force it ; because that avoids the possibility of it fluctuating across different ; verbosity levels. ;-------------------------------------------------- ; Check with both the annotation label and the line number fairly short. ; ; RUN: echo 'hello world' > %t.in ; RUN: echo 'CHECK: hello world' > %t.chk ; ; REDEFINE: %{opts} = -dump-input-label-width=0 ; REDEFINE: %{pre} = WIDTH-SHORT ; RUN: %{run-v} ; ; WIDTH-SHORT:<<<<<< ; WIDTH-SHORT-NEXT: 1: hello world ; WIDTH-SHORT-NEXT:check:1 ^~~~~~~~~~~ ; WIDTH-SHORT-NEXT:>>>>>> ; WIDTH-SHORT-NOT:{{.}} ; Check that lengthening the annotation label widens the column. ; ; RUN: echo 'hello world' > %t.in ; RUN: echo 'hello world' >> %t.in ; RUN: echo 'CHECK-COUNT-2: hello world' > %t.chk ; ; REDEFINE: %{opts} = -dump-input-label-width=0 ; REDEFINE: %{pre} = WIDTH-ANNOT ; RUN: %{run-v} ; ; WIDTH-ANNOT:<<<<<< ; WIDTH-ANNOT-NEXT: 1: hello world ; WIDTH-ANNOT-NEXT:count:1'0 ^~~~~~~~~~~ ; WIDTH-ANNOT-NEXT: 2: hello world ; WIDTH-ANNOT-NEXT:count:1'1 ^~~~~~~~~~~ ; WIDTH-ANNOT-NEXT:>>>>>> ; WIDTH-ANNOT-NOT:{{.}} ; Check that a longer line number (6 characters) than annotation label (5 ; characters) widens the column. ; ; RUN: %python -c 'print("x\n" * 10**5, end="")' > %t.in ; RUN: echo 'the end' >> %t.in ; RUN: echo 'CHECK-DAG: the end' > %t.chk ; ; REDEFINE: %{opts} = -dump-input-label-width=0 -dump-input-filter=annotation \ ; REDEFINE: -dump-input-context=3 ; REDEFINE: %{pre} = WIDTH-LINENO ; RUN: %{run-v} ; ; WIDTH-LINENO:<<<<<< ; WIDTH-LINENO-NEXT: . ; WIDTH-LINENO-NEXT: . ; WIDTH-LINENO-NEXT: . ; WIDTH-LINENO-NEXT: 99998: x ; WIDTH-LINENO-NEXT: 99999: x ; WIDTH-LINENO-NEXT: 100000: x ; WIDTH-LINENO-NEXT: 100001: the end ; WIDTH-LINENO-NEXT:dag:1 ^~~~~~~ ; WIDTH-LINENO-NEXT:>>>>>> ; WIDTH-LINENO-NOT:{{.}} ; REDEFINE: %{opts} = ;-------------------------------------------------- ; 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 ; REDEFINE: %{pre} = CHK ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; 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- ;-------------------------------------------------- ; 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 ; REDEFINE: %{pre} = CNT ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; Verbose diagnostics are suppressed but not errors. ; CNT:{{.*}}error:{{.*}} ; CNT-V:<<<<<< ; CNT-V-NEXT: 1: pete ; CNT-V-NEXT:count:1'0 ^~~~ ; CNT-V-NEXT: 2: repete ; CNT-V-NEXT:count:1'1 ^~~~ ; CNT-V-NEXT:count:1'2 X error: no match found ; CNT-V-NEXT: 3: repeat ; CNT-V-NEXT:count:1'2 ~~~~~~~ ; CNT-V-NEXT:count:1'3 ? possible intended match ; CNT-V-NEXT:>>>>>> ; CNT-V-NOT:{{.}} ; CNT-Q:<<<<<< ; CNT-Q-NEXT: 1: pete ; CNT-Q-NEXT: 2: repete ; CNT-Q-NEXT:count:1'0 X error: no match found ; CNT-Q-NEXT: 3: repeat ; CNT-Q-NEXT:count:1'0 ~~~~~~~ ; CNT-Q-NEXT:count:1'1 ? possible intended match ; CNT-Q-NEXT:>>>>>> ; CNT-Q-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 ; REDEFINE: %{pre} = NXT ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; 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 ; REDEFINE: %{pre} = NXT2 ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; Verbose diagnostics are suppressed but not errors. ; NXT2:{{.*}}error:{{.*}} ; NXT2:<<<<<< ; NXT2-NEXT: 1: hello ; NXT2-V-NEXT:check:1 ^~~~~ ; NXT2-NEXT: 2: again ; NXT2-V-NEXT:next:2 ^~~~~ ; 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 ; REDEFINE: %{pre} = SAM ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; 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 ; REDEFINE: %{pre} = SAM2 ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; Verbose diagnostics are suppressed but not errors. ; SAM2:{{.*}}error:{{.*}} ; SAM2:<<<<<< ; SAM2-NEXT: 1: hello world! ; SAM2-V-NEXT:check:1 ^~~~~ ; SAM2-V-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 ; REDEFINE: %{pre} = EMP ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; 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 ; REDEFINE: %{pre} = EMP2 ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; 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 ; REDEFINE: %{pre} = NOT ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; 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 ; REDEFINE: %{pre} = NOT2 ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; 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 ; REDEFINE: %{pre} = DAG ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; Verbose diagnostics are suppressed but not errors. ; DAG:{{.*}}error:{{.*}} ; DAG-VV:<<<<<< ; DAG-VV-NEXT: 1: abc ; DAG-VV-NEXT:dag:2 ^~~ ; DAG-VV-NEXT:dag:3'0 !~~ discard: overlaps earlier match ; DAG-VV-NEXT: 2: def ; DAG-VV-NEXT:dag:1 ^~~ ; DAG-VV-NEXT:dag:4'0 !~~ discard: overlaps earlier match ; DAG-VV-NEXT:dag:4'1 X error: no match found ; DAG-VV-NEXT: 3: abc ; DAG-VV-NEXT:dag:3'1 ^~~ ; DAG-VV-NEXT:dag:4'1 ~~~~ ; DAG-VV-NEXT:>>>>>> ; DAG-VV-NOT:{{.}} ; DAG-VQ:<<<<<< ; DAG-VQ-NEXT: 1: abc ; DAG-VQ-NEXT:dag:2 ^~~ ; DAG-VQ-NEXT: 2: def ; DAG-VQ-NEXT:dag:1 ^~~ ; DAG-VQ-NEXT:dag:4 X error: no match found ; DAG-VQ-NEXT: 3: abc ; DAG-VQ-NEXT:dag:3 ^~~ ; DAG-VQ-NEXT:dag:4 ~~~~ ; DAG-VQ-NEXT:>>>>>> ; DAG-VQ-NOT:{{.}} ; DAG-Q:<<<<<< ; DAG-Q-NEXT: 1: abc ; DAG-Q-NEXT: 2: def ; DAG-Q-NEXT:dag:4 X error: no match found ; DAG-Q-NEXT: 3: abc ; DAG-Q-NEXT:dag:4 ~~~~ ; DAG-Q-NEXT:>>>>>> ; DAG-Q-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 ; REDEFINE: %{pre} = DAG1L ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; Verbose diagnostics are suppressed but not errors. ; DAG1L:{{.*}}error:{{.*}} ; DAG1L-VV:<<<<<< ; DAG1L-VV-NEXT: 1: abc def abc def ; DAG1L-VV-NEXT:dag:1 ^~~ ; DAG1L-VV-NEXT:dag:2 ^~ ; DAG1L-VV-NEXT:dag:3'0 !~~ discard: overlaps earlier match ; DAG1L-VV-NEXT:dag:3'1 ^~~ ; DAG1L-VV-NEXT:dag:4'0 !~ discard: overlaps earlier match ; 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-VV-NEXT:dag:5'2 X~ error: no match found ; DAG1L-VV-NEXT:>>>>>> ; DAG1L-VV-NOT:{{.}} ; DAG1L-VQ:<<<<<< ; DAG1L-VQ-NEXT: 1: abc def abc def ; DAG1L-VQ-NEXT:dag:1 ^~~ ; DAG1L-VQ-NEXT:dag:2 ^~ ; DAG1L-VQ-NEXT:dag:3 ^~~ ; DAG1L-VQ-NEXT:dag:4 ^~ ; DAG1L-VQ-NEXT:dag:5 X~ error: no match found ; DAG1L-VQ-NEXT:>>>>>> ; DAG1L-VQ-NOT:{{.}} ; DAG1L-Q:<<<<<< ; DAG1L-Q-NEXT: 1: abc def abc def ; DAG1L-Q-NEXT:dag:5 X~ error: no match found ; DAG1L-Q-NEXT:>>>>>> ; DAG1L-Q-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 ; REDEFINE: %{pre} = LAB ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; 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-V:<<<<<< ; LAB-V-NEXT: 1: text ; LAB-V-NEXT:check:1 ^~~~ ; LAB-V-NEXT: 2: labelA ; LAB-V-NEXT:label:2'0 ^~~~~~ ; LAB-V-NEXT:label:2'1 ^~~~~~ ; LAB-V-NEXT:check:3 X error: no match found ; LAB-V-NEXT: 3: textA ; LAB-V-NEXT:check:3 ~~~~~~ ; LAB-V-NEXT: 4: labelB ; LAB-V-NEXT:label:4 ^~~~~~ ; LAB-V-NEXT:check:3 ~~~~~~ ; LAB-V-NEXT: 5: textB ; LAB-V-NEXT: 6: labelC ; LAB-V-NEXT:label:6'0 ^~~~~~ ; LAB-V-NEXT:check:5 ^~~~~~ ; LAB-V-NEXT:label:6'1 X error: no match found ; LAB-VV-NEXT:not:7 X ; LAB-V-NEXT: 7: textC ; LAB-VV-NEXT:not:7 ~~~~~~ ; LAB-V-NEXT: 8: labelD ; LAB-V-NEXT:label:8'0 ^~~~~~ ; LAB-V-NEXT:label:8'1 ^~~~~~ ; LAB-V-NEXT: 9: textD ; LAB-V-NEXT:not:9 !~~~~ error: no match expected ; LAB-V-NEXT: 10: labelE ; LAB-V-NEXT:label:10'0 ^~~~~~ ; LAB-V-NEXT:label:10'1 ^~~~~~ ; LAB-VV-NEXT:not:11 X ; LAB-V-NEXT: 11: textE ; LAB-VV-NEXT:not:11 ~~~~~~ ; LAB-V-NEXT: 12: labelF ; LAB-V-NEXT:label:12'0 ^~~~~~ ; LAB-V-NEXT:label:12'1 ^~~~~~ ; LAB-V-NEXT:>>>>>> ; LAB-V-NOT:{{.}} ; LAB-Q:<<<<<< ; LAB-Q-NEXT: 1: text ; LAB-Q-NEXT: 2: labelA ; LAB-Q-NEXT:check:3 X error: no match found ; LAB-Q-NEXT: 3: textA ; LAB-Q-NEXT:check:3 ~~~~~~ ; LAB-Q-NEXT: 4: labelB ; LAB-Q-NEXT:check:3 ~~~~~~ ; LAB-Q-NEXT: 5: textB ; LAB-Q-NEXT: 6: labelC ; LAB-Q-NEXT:label:6 X error: no match found ; LAB-Q-NEXT: 7: textC ; LAB-Q-NEXT: 8: labelD ; LAB-Q-NEXT: 9: textD ; LAB-Q-NEXT:not:9 !~~~~ error: no match expected ; LAB-Q-NEXT: 10: labelE ; LAB-Q-NEXT: 11: textE ; LAB-Q-NEXT: 12: labelF ; LAB-Q-NEXT:>>>>>> ; LAB-Q-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 ; REDEFINE: %{pre} = IMPNOT ; REDEFINE: %{opts} = \ ; REDEFINE: --implicit-check-not='goodbye' \ ; REDEFINE: --implicit-check-not='world' \ ; REDEFINE: --implicit-check-not='again' ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; REDEFINE: %{opts} = ; Verbose diagnostics are suppressed but not errors. ; IMPNOT:{{.*}}command line:1:22: error: IMPLICIT-CHECK-NOT: excluded string found in input ; IMPNOT-VV:<<<<<< ; IMPNOT-VV-NEXT: 1: hello world again! ; IMPNOT-VV-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-VV-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-VV-NEXT:check:3 ^ ; IMPNOT-VV-NEXT:not:imp1'2 X~~~~~~~ ; IMPNOT-VV-NEXT:not:imp2'2 X~~~~~~~ ; IMPNOT-VV-NEXT:not:imp3'2 !~~~~ error: no match expected ; IMPNOT-VV-NEXT:>>>>>> ; IMPNOT-VV-NOT:{{.}} ; IMPNOT-VQ:<<<<<< ; IMPNOT-VQ-NEXT: 1: hello world again! ; IMPNOT-VQ-NEXT:check:1 ^~~ ; IMPNOT-VQ-NEXT:check:2 ^~~ ; IMPNOT-VQ-NEXT:check:3 ^ ; IMPNOT-VQ-NEXT:not:imp3 !~~~~ error: no match expected ; IMPNOT-VQ-NEXT:>>>>>> ; IMPNOT-VQ-NOT:{{.}} ; IMPNOT-Q:<<<<<< ; IMPNOT-Q-NEXT: 1: hello world again! ; IMPNOT-Q-NEXT:not:imp3 !~~~~ error: no match expected ; IMPNOT-Q-NEXT:>>>>>> ; IMPNOT-Q-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 ; REDEFINE: %{pre} = SUBST-POS ; REDEFINE: %{opts} = \ ; REDEFINE: -DDEF_MATCH1=def-match1 -DDEF_MATCH2=def-match2 \ ; REDEFINE: -DDEF_NOMATCH=foobar ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; REDEFINE: %{opts} = ; Verbose diagnostics are suppressed but not errors. ; SUBST-POS:{{.*}}error:{{.*}} ; SUBST-POS:{{.*}}possible intended match here{{.*}} ; SUBST-POS:<<<<<< ; SUBST-POS-NEXT: 1: def-match1 def-match2 ; SUBST-POS-V-NEXT:check:1'0 ^~~~~~~~~~~~~~~~~~~~~ ; SUBST-POS-V-NEXT:check:1'1 with "DEF_MATCH1" equal to "def-match1" ; SUBST-POS-V-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 ; REDEFINE: %{pre} = SUBST-NEG ; REDEFINE: %{opts} = \ ; REDEFINE: -DDEF_MATCH1=def-match1 -DDEF_MATCH2=def-match2 \ ; REDEFINE: -DDEF_NOMATCH=foobar ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; REDEFINE: %{opts} = ; Verbose diagnostics are suppressed but not errors. ; SUBST-NEG-COUNT-2:{{.*}}error:{{.*}} ; 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-V-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 ; REDEFINE: %{pre} = CAPTURE-NEG ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; Verbose diagnostics are suppressed but not errors. ; CAPTURE-NEG:{{.*}}error:{{.*}} ; CAPTURE-NEG:<<<<<< ; CAPTURE-NEG-NEXT: 1: strvar: foo ; CAPTURE-NEG-V-NEXT:check:1'0 ^~~~~~~~~~~ CAPTURE-NEG-V-NEXT:check:1'1 ^~~ captured var "STRVAR" ; CAPTURE-NEG-NEXT: 2: numvar no expr: 51 ; CAPTURE-NEG-V-NEXT:check:2'0 ^~~~~~~~~~~~~~~~~~ ; CAPTURE-NEG-V-NEXT:check:2'1 ^~ captured var "NUMVAR_NO_EXPR" ; CAPTURE-NEG-NEXT: 3: numvar expr: -49 ; CAPTURE-NEG-V-NEXT:check:3'0 ^~~~~~~~~~~~~~~~ ; CAPTURE-NEG-V-NEXT:check:3'1 with "%d,NUMVAR_EXPR:2-NUMVAR_NO_EXPR" equal to "-49" ; CAPTURE-NEG-V-NEXT:check:3'2 ^~~ captured var "NUMVAR_EXPR" ; CAPTURE-NEG-NEXT: 4: many: foo 100 8 bar ; CAPTURE-NEG-V-NEXT:check:4'0 ^~~~~~~~~~~~~~~~~~~ ; CAPTURE-NEG-V-NEXT:check:4'1 ^~~ captured var "VAR1" ; CAPTURE-NEG-V-NEXT:check:4'2 ^~~ captured var "VAR3" ; CAPTURE-NEG-V-NEXT:check:4'3 ^ captured var "VAR2" ; CAPTURE-NEG-V-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-V-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 ; REDEFINE: %{pre} = SUBST_NEXT ; REDEFINE: %{opts} = -DVAR=var ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; REDEFINE: %{opts} = ; Verbose diagnostics are suppressed but not errors. ; SUBST_NEXT:{{.*}}error:{{.*}} ; SUBST_NEXT-V:<<<<<< ; SUBST_NEXT-V-NEXT: 1: pre var ; SUBST_NEXT-V-NEXT:check:1 ^~~ ; SUBST_NEXT-V-NEXT:next:2'0 !~~ error: match on wrong line ; SUBST_NEXT-V-NEXT:next:2'1 with "VAR" equal to "var" ; SUBST_NEXT-V-NEXT:>>>>>> ; SUBST_NEXT-Q:<<<<<< ; SUBST_NEXT-Q-NEXT: 1: pre var ; SUBST_NEXT-Q-NEXT:next:2 !~~ error: match on wrong line ; SUBST_NEXT-Q-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 ; REDEFINE: %{pre} = SUBST_SAME ; REDEFINE: %{opts} = -DVAR=var ; RUN: not %{run-vv} ; RUN: not %{run-v} ; RUN: not %{run} ; REDEFINE: %{opts} = ; Verbose diagnostics are suppressed but not errors. ; SUBST_SAME:{{.*}}error:{{.*}} ; SUBST_SAME-V:<<<<<< ; SUBST_SAME-V-NEXT: 1: pre ; SUBST_SAME-V-NEXT:check:1 ^~~ ; SUBST_SAME-V-NEXT: 2: var ; SUBST_SAME-V-NEXT:same:2'0 !~~ error: match on wrong line ; SUBST_SAME-V-NEXT:same:2'1 with "VAR" equal to "var" ; SUBST_SAME-V-NEXT:>>>>>> ; SUBST_SAME-Q:<<<<<< ; SUBST_SAME-Q-NEXT: 1: pre ; SUBST_SAME-Q-NEXT: 2: var ; SUBST_SAME-Q-NEXT:same:2 !~~ error: match on wrong line ; SUBST_SAME-Q-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 ; REDEFINE: %{pre} = SUBST_DAG ; REDEFINE: %{opts} = -DVAR=var ; RUN: %{run-vv} ; RUN: %{run-v} ; RUN: %{run} ; REDEFINE: %{opts} = ; SUBST_DAG-VV:<<<<<< ; SUBST_DAG-VV-NEXT: 1: var ; SUBST_DAG-VV-NEXT:dag:1 ^~~ ; SUBST_DAG-VV-NEXT:dag:2'0 !~~ discard: overlaps earlier match ; SUBST_DAG-VV-NEXT:dag:2'1 with "VAR" equal to "var" ; SUBST_DAG-VV-NEXT: 2: var ; SUBST_DAG-VV-NEXT:dag:2'2 ^~~ ; SUBST_DAG-VV-NEXT:dag:2'3 with "VAR" equal to "var" ; SUBST_DAG-VV-NEXT: 3: END ; SUBST_DAG-VV-NEXT:check:3 ^~~ ; SUBST_DAG-VV-NEXT:>>>>>> ; SUBST_DAG-VQ:<<<<<< ; SUBST_DAG-VQ-NEXT: 1: var ; SUBST_DAG-VQ-NEXT:dag:1 ^~~ ; SUBST_DAG-VQ-NEXT: 2: var ; SUBST_DAG-VQ-NEXT:dag:2'0 ^~~ ; SUBST_DAG-VQ-NEXT:dag:2'1 with "VAR" equal to "var" ; SUBST_DAG-VQ-NEXT: 3: END ; SUBST_DAG-VQ-NEXT:check:3 ^~~ ; SUBST_DAG-VQ-NEXT:>>>>>> ; SUBST_DAG-Q:<<<<<< ; SUBST_DAG-Q-NEXT: 1: var ; SUBST_DAG-Q-NEXT: 2: var ; SUBST_DAG-Q-NEXT: 3: END ; SUBST_DAG-Q-NEXT:>>>>>>