[lit] RUN commands without stdin.

[csigg]

Summary

This changes the initial stdin of a lit RUN command to be None, so that tools taking input from stdin do not see a zero-length input.

This will prevent issues like that one fixed in commit 720dd81.

[probinson]

So what would such a tool see? Would it get an error trying to open stdin, or something else?

Needs a test in lit's own test suite.

[csigg]

Add test, fix external shell mode.

[csigg]

Fix bazel config to actually test lit tests.

Create a separate test instead of reusing the shtest-timeout one.

[csigg]

In D135067#3830815, @probinson wrote:

So what would such a tool see? Would it get an error trying to open stdin, or something else?

A tool reading from stdin would get stdin, not an error and not an empty string (which it did before this change).

Needs a test in lit's own test suite.

Done.

[probinson]

In D135067#3832848, @csigg wrote:

In D135067#3830815, @probinson wrote:

So what would such a tool see? Would it get an error trying to open stdin, or something else?

A tool reading from stdin would get stdin, not an error and not an empty string (which it did before this change).

Ah. I interpreted that to mean "it will hang waiting for input" and then I see the test expects lit to timeout the test. That works.

LGTM

[csigg]

Fix clang tests that relied on empty input or accidentally did not provide the input in the RUN directive.

[jhenderson]

llvm/utils/lit/tests/Inputs/shtest-stdin/print-stdin.py

6

Nit: add newline at EOF.

llvm/utils/lit/tests/shtest-stdin.py

28

Nit: Don't have multiple \n at EOF (there should be exactly one).

clang/test/Analysis/analyzer-checker-config.c

-// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config unix.mallo:Optimistic=true 2>&1 | FileCheck %s
-// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config uni:Optimistic=true 2>&1 | FileCheck %s
-// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config uni.:Optimistic=true 2>&1 | FileCheck %s
-// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config ..:Optimistic=true 2>&1 | FileCheck %s
-// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config unix.:Optimistic=true 2>&1 | FileCheck %s
-// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config unrelated:Optimistic=true 2>&1 | FileCheck %s
-// RUN: %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config unix.DynamicMemoryModeling:Optimistic=true
+// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config unix.mallo:Optimistic=true %s 2>&1 | FileCheck %s
+// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config uni:Optimistic=true %s 2>&1 | FileCheck %s
+// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config uni.:Optimistic=true %s 2>&1 | FileCheck %s
+// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config ..:Optimistic=true %s 2>&1 | FileCheck %s
+// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config unix.:Optimistic=true %s 2>&1 | FileCheck %s
+// RUN: not %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config unrelated:Optimistic=true %s 2>&1 | FileCheck %s
+// RUN:     %clang_analyze_cc1 -analyzer-checker=core,unix.Malloc -analyzer-config unix.DynamicMemoryModeling:Optimistic=true %s 2>&1
 
-// Just to test clang is working.
-# foo
-
-// CHECK: error:
+// CHECK: error: no analyzer checkers or packages are associated with

clang/test/Analysis/analyzer-config.c

-// RUN: %clang_analyze_cc1 -analyzer-checker=debug.ConfigDumper > %t 2>&1
+// RUN: %clang_analyze_cc1 -analyzer-checker=debug.ConfigDumper %s > %t 2>&1
 // RUN: FileCheck --input-file=%t %s --match-full-lines
 
 // CHECK:      [config]
 // CHECK-NEXT: add-pop-up-notes = true
 // CHECK-NEXT: aggressive-binary-operation-simplification = false
 // CHECK-NEXT: alpha.clone.CloneChecker:IgnoredFilesPattern = ""
 // CHECK-NEXT: alpha.clone.CloneChecker:MinimumCloneComplexity = 50
 // CHECK-NEXT: alpha.clone.CloneChecker:ReportNormalClones = true

clang/test/Driver/cc1-response-files.c

-// RUN: %clang @%S/Inputs/cc1-response.txt -fsyntax-only -disable-llvm-passes
+// RUN: %clang @%S/Inputs/cc1-response.txt -fsyntax-only -disable-llvm-passes %s
 int main() {}

clang/test/Interpreter/incremental-mode.cpp

-// RUN: clang-repl -Xcc -E
-// RUN: clang-repl -Xcc -emit-llvm 
+// RUN: clang-repl -Xcc -E %s
+// RUN: clang-repl -Xcc -emit-llvm %s
 // expected-no-diagnostics

clang/test/Modules/load-module-with-errors.m

void test(Error *x) {
   funcb(x);
   [x method];
 }
 
 // RUN: rm -rf %t
 // RUN: mkdir %t
 // RUN: mkdir %t/prebuilt
 
-// RUN: %clang_cc1 -fmodules -fallow-pcm-with-compiler-errors \
+// RUN: echo "" | %clang_cc1 -fmodules -fallow-pcm-with-compiler-errors \
 // RUN:   -fmodule-name=error -o %t/prebuilt/error.pcm \
 // RUN:   -x objective-c -emit-module %S/Inputs/error/module.modulemap
-// RUN: %clang_cc1 -fmodules -fallow-pcm-with-compiler-errors \
+// RUN: echo "" | %clang_cc1 -fmodules -fallow-pcm-with-compiler-errors \
 // RUN:   -fmodule-file=error=%t/prebuilt/error.pcm \
 // RUN:   -fmodule-name=use_error_a -o %t/prebuilt/use_error_a.pcm \
 // RUN:   -x objective-c -emit-module %S/Inputs/error/module.modulemap
-// RUN: %clang_cc1 -fmodules -fallow-pcm-with-compiler-errors \
+// RUN: echo "" | %clang_cc1 -fmodules -fallow-pcm-with-compiler-errors \
 // RUN:   -fmodule-file=error=%t/prebuilt/error.pcm \
 // RUN:   -fmodule-name=use_error_b -o %t/prebuilt/use_error_b.pcm \
 // RUN:   -x objective-c -emit-module %S/Inputs/error/module.modulemap
 
 // Prebuilt modules
 // RUN: %clang_cc1 -fsyntax-only -fmodules -fallow-pcm-with-compiler-errors \
 // RUN:   -fprebuilt-module-path=%t/prebuilt -fmodules-cache-path=%t \
 // RUN:   -ast-print %s | FileCheck %s

 // RUN:   -fmodule-file=%t/prebuilt/use_error_b.pcm \
 // RUN:   -fmodules-cache-path=%t -ast-print %s | FileCheck %s
 // As the modules are always loaded, compiling will fail before even parsing
 // this file - this means that -verify can't be used, so do a grep instead.
 // RUN: not %clang_cc1 -fsyntax-only -fmodules \
 // RUN:   -fmodule-file=%t/prebuilt/error.pcm \
 // RUN:   -fmodule-file=%t/prebuilt/use_error_a.pcm \
 // RUN:   -fmodule-file=%t/prebuilt/use_error_b.pcm \
-// RUN:   -fmodules-cache-path=%t 2>&1 | \
+// RUN:   -fmodules-cache-path=%t %s 2>&1 | \
 // RUN: grep "PCH file contains compiler errors"
 
 // Shouldn't build the cached modules (that have errors) when not allowing
 // errors
 // RUN: not %clang_cc1 -fsyntax-only -fmodules \
 // RUN:   -fmodules-cache-path=%t -fimplicit-module-maps -I %S/Inputs/error \
 // RUN:   -x objective-c %s
 // RUN: find %t -name "error-*.pcm" | not grep error

 // Should rebuild the cached module if it had an error (if it wasn't rebuilt
 // the verify would fail as it would be the PCH error instead)
 // RUN: %clang_cc1 -fsyntax-only -fmodules \
 // RUN:   -fmodules-cache-path=%t -fimplicit-module-maps -I %S/Inputs/error \
 // RUN:   -x objective-c  %s -verify=notallowerror
 
 // allow-pcm-with-compiler-errors should also allow errors in PCH
 // RUN: %clang_cc1 -fallow-pcm-with-compiler-errors -x objective-c \
-// RUN:   -o %t/check.pch -emit-pch %S/Inputs/error/error.h
+// RUN:   -o %t/check.pch -emit-pch %S/Inputs/error/error.h %s
 
 // CHECK: @interface Error
 // CHECK-NEXT: - (int)method;
 // CHECK-NEXT: - (id)method2;
 // CHECK-NEXT: @end
 // CHECK: void test(Error *x)
 
 // RUN: c-index-test -code-completion-at=%s:12:6 %s -fmodules -fmodules-cache-path=%t \

clang/test/OpenMP/target_uses_allocators.c

 // Test host codegen.
-// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=50  -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix CHECK --check-prefix CHECK-64
+// RUN: %clang_cc1 -verify -fopenmp -fopenmp-version=50 -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-llvm %s -o - | FileCheck %s
 // RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu -emit-pch -o %t %s
-// RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu
+// RUN: %clang_cc1 -fopenmp -fopenmp-version=50 -x c++ -triple powerpc64le-unknown-unknown -fopenmp-targets=powerpc64le-ibm-linux-gnu %s
 
 // expected-no-diagnostics
 #ifndef HEADER
 #define HEADER
 
 enum omp_allocator_handle_t {
   omp_null_allocator = 0,
   omp_default_mem_alloc = 1,

clang/test/Preprocessor/elfiamcu-predefines.c

-// RUN: %clang_cc1 -E -dM -triple i586-intel-elfiamcu | FileCheck %s
+// RUN: %clang_cc1 -E -dM -triple i586-intel-elfiamcu %s | FileCheck %s
 
 // CHECK: #define __USER_LABEL_PREFIX__ {{$}}
 // CHECK: #define __WINT_TYPE__ unsigned int
 // CHECK: #define __iamcu
 // CHECK: #define __iamcu__
 

llvm/utils/lit/lit/TestRunner.py

if isinstance(cmd, ShUtil.Seq):
                 res = _executeShCmd(cmd.rhs, shenv, results, timeoutHelper)
             return res
 
         raise ValueError('Unknown shell command: %r' % cmd.op)
     assert isinstance(cmd, ShUtil.Pipeline)
 
     procs = []
     proc_not_counts = []
-    default_stdin = subprocess.PIPE
+    default_stdin = None
     stderrTempFiles = []
     opened_files = []
     named_temp_files = []
     builtin_commands = set(['cat', 'diff'])
     builtin_commands_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "builtin_commands")
     inproc_builtins = {'cd': executeBuiltinCd,
                        'export': executeBuiltinExport,
                        'echo': executeBuiltinEcho,

llvm/utils/lit/lit/util.py

 
 def executeCommand(command, cwd=None, env=None, input=None, timeout=0,
                    redirect_stderr=False):
     """Execute command ``command`` (list of arguments or string) with.
 
     * working directory ``cwd`` (str), use None to use the current
       working directory
     * environment ``env`` (dict), use None for none
-    * Input to the command ``input`` (str), use string to pass
+    * Input to the command ``input`` (str), use None to pass
       no input.
     * Max execution time ``timeout`` (int) seconds. Use 0 for no timeout.
     * ``redirect_stderr`` (bool), use True if redirect stderr to stdout
 
     Returns a tuple (out, err, exitCode) where
     * ``out`` (str) is the standard output of running the command
     * ``err`` (str) is the standard error of running the command
     * ``exitCode`` (int) is the exitCode of running the command
 
     If the timeout is hit an ``ExecuteCommandTimeoutException``
     is raised.
 
     """
     if input is not None:
         input = to_bytes(input)
     err_out = subprocess.STDOUT if redirect_stderr else subprocess.PIPE
     p = subprocess.Popen(command, cwd=cwd,
-                         stdin=subprocess.PIPE,
+                         stdin=subprocess.PIPE if input else None,
                          stdout=subprocess.PIPE,
                          stderr=err_out,
                          env=env, close_fds=kUseCloseFDs)
     timerObject = None
     # FIXME: Because of the way nested function scopes work in Python 2.x we
     # need to use a reference to a mutable object rather than a plain
     # bool. In Python 3 we could use the "nonlocal" keyword but we need
     # to support Python 2 as well.

llvm/utils/lit/tests/Inputs/shtest-stdin/lit.cfg

+# -*- Python -*-
+import os
+import sys
+
+import lit.formats
+
+config.name = 'shtest-stdin'
+
+externalShell = lit_config.params.get('external', '1') != '0'
+config.test_format = lit.formats.ShTest(execute_external=externalShell)
+config.suffixes = ['.py']
+
+config.test_source_root = os.path.dirname(__file__)
+config.test_exec_root = config.test_source_root
+config.target_triple = '(unused)'
+src_root = os.path.join(config.test_source_root, '..')
+
+pythonpath_list = [src_root]
+# Ensure the user's PYTHONPATH is included.
+if 'PYTHONPATH' in os.environ:
+    pythonpath_list.append(os.environ['PYTHONPATH'])
+if 'PYTHONPATH' in config.environment:
+    pythonpath_list.append(config.environment['PYTHONPATH'])
+config.environment['PYTHONPATH'] = os.pathsep.join(pythonpath_list)
+
+config.substitutions.append(('%{python}', '"%s"' % (sys.executable)))

llvm/utils/lit/tests/Inputs/shtest-stdin/print-stdin.py

+# Checks that lit provides no input to stdin.
+# RUN: %{python} %s
+import sys
+
+print(sys.stdin.read())
 No newline at end of file

llvm/utils/lit/tests/shtest-stdin.py

+# REQUIRES: lit-max-individual-test-time
+
+###############################################################################
+# Check tests do not receive spurious stdin input.
+###############################################################################
+# RUN: not %{lit} %{inputs}/shtest-stdin/print-stdin.py \
+# RUN:   --param external=0 --timeout 1 \
+# RUN: | FileCheck --check-prefix=CHECK-STDIN %s
+#
+# RUN: not %{lit} %{inputs}/shtest-stdin/print-stdin.py \
+# RUN:   --param external=1 --timeout 1 \
+# RUN: | FileCheck --check-prefix=CHECK-STDIN %s
+#
+# CHECK-STDIN: TIMEOUT: shtest-stdin :: print-stdin.py
+
+###############################################################################
+# Check tests do receive piped stdin input.
+###############################################################################
+# RUN: echo foobar | %{lit} %{inputs}/shtest-stdin/print-stdin.py \
+# RUN:   --param external=0 -a \
+# RUN: | FileCheck --check-prefix=CHECK-PIPE %s
+#
+# RUN: echo foobar | %{lit} %{inputs}/shtest-stdin/print-stdin.py \
+# RUN:   --param external=1 -a \
+# RUN: | FileCheck --check-prefix=CHECK-PIPE %s
+#
+# CHECK-PIPE: foobar
+

utils/bazel/llvm-project-overlay/llvm/utils/lit/tests/BUILD.bazel

lit_test(
             "lit.cfg",
             "lit.site.cfg",
             "check-tested-lit-timeout-ability",
             "//llvm:FileCheck",
             "//llvm:count",
             "//llvm:not",
         ] + glob(["Inputs/**"]),
     )
-    for src in glob(["*/*.py"])
+    for src in glob(
+        include = ["**/*.py"],
+        exclude = [
+            "Inputs/**",
+            # FIXME: these tests fail under bazel.
+            "discovery.py",
+            "max-time.py",
+            "selecting.py",
+            "shtest-recursive-substitution.py",
+        ]
+    )
 ]