derek.holloway
7502bf64a4
CodeQL / Analyze (actions) (push) Canceled after 0s
CodeQL / Analyze (python) (push) Canceled after 0s
pre-commit / pre-commit (push) Canceled after 0s
Multi-Arch CI / setup (push) Canceled after 0s
Publish build_manylinux_x86_64 images / publish_build_manylinux_x86_64 (push) Canceled after 0s
Setup (Multi-Arch) / setup (push) Canceled after 0s
Multi-Arch CI / Linux::${{ fromJSON(needs.setup.outputs.linux_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubi10 image / publish_no_rocm_image_ubi10 (push) Canceled after 0s
Multi-Arch CI / Windows::${{ fromJSON(needs.setup.outputs.windows_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Multi-Arch CI / Manifest Diff (push) Canceled after 0s
TheRock Manifest Diff Report / Generate Manifest Diff Report (push) Canceled after 0s
Multi-Arch CI / CI Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_ocl_rt images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_rocgdb images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Unit Tests / Unit Tests :: ubuntu-24.04 (push) Canceled after 0s
Unit Tests / Unit Tests :: windows-2022 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_media (push) Canceled after 0s
Unit Tests / Unit Tests Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_openmpi (push) Canceled after 0s
952 lines
32 KiB
Plaintext
952 lines
32 KiB
Plaintext
; 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-<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
|
|
|
|
; 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:>>>>>>
|