[libc++] [libc++abi] Correctly quote source and target names in tests. NFC.

[ldionne]

Summary

That fixes issues when using directories (source or build) containing e.g. spaces.
It *should* not break anything as it's just adding quotes where they were missing.

[Mordante]

One minor question, otherwise LGTM.

libcxx/test/libcxx/gdb/gdb_pretty_printer_test.sh.cpp

16

While you're at it, would it make sense to also guard %{cxx} and %{gdb}?

[curdeius]

Ok. For the moment I just fixed what was failing with my current setup but will fix cxx and gdb too.

[curdeius]

• Quote {gdb}.

[curdeius]

libcxx/test/libcxx/gdb/gdb_pretty_printer_test.sh.cpp

16

FYI, cxx was already correctly quoted. I added quoting to gdb. There are other issues in other parts of LLVM tho (e.g. one cannot build clang in a build dir with spaces) but I'll handle that in different patches.

[Mordante]

Thanks, LGTM.

[compnerd]

libcxx/test/CMakeLists.txt

85

I believe that this doesn't work properly on Windows. The quoting rules on Windows are quite different. Using " instead of ' would work. However, depending on how this is used, CMake should be able to handle the quoting appropriately per platform.

libcxx/utils/libcxx/test/dsl.py

98

Please use pipes.quote for the argument quoting.

libcxx/utils/libcxx/test/format.py

73–74

Please use pipes.quote for the quoted parameters (and the same throughout the rest of the lit configuration).

[ldionne]

[Github PR transition cleanup]

Abandoning since this would likely need to be re-done almost entirely if rebased.

libcxx/test/CMakeLists.txt

 # directory.
 if (NOT LIBCXX_CXX_ABI_LIBRARY_PATH)
   set(LIBCXX_CXX_ABI_LIBRARY_PATH "${LIBCXX_LIBRARY_DIR}" CACHE PATH
       "The path to libc++abi library.")
 endif()
 
 set(LIBCXX_TARGET_INFO "libcxx.test.target_info.LocalTI" CACHE STRING
     "TargetInfo to use when setting up test environment.")
-set(LIBCXX_EXECUTOR "${Python3_EXECUTABLE} ${CMAKE_CURRENT_LIST_DIR}/../utils/run.py" CACHE STRING
+set(LIBCXX_EXECUTOR "${Python3_EXECUTABLE} '${CMAKE_CURRENT_LIST_DIR}/../utils/run.py'" CACHE STRING
     "Executor to use when running tests.")
 
 set(AUTO_GEN_COMMENT "## Autogenerated by libcxx configuration.\n# Do not edit!")
 
 if (NOT DEFINED LIBCXX_TEST_DEPS)
   message(FATAL_ERROR "Expected LIBCXX_TEST_DEPS to be defined")
 endif()
 

libcxx/test/libcxx/double_include.sh.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Test that we can include each header in two TU's and link them together.
 
-// RUN: %{cxx} -c %s -o %t.first.o %{flags} %{compile_flags}
-// RUN: %{cxx} -c %s -o %t.second.o -DWITH_MAIN %{flags} %{compile_flags}
-// RUN: %{cxx} -o %t.exe %t.first.o %t.second.o %{flags} %{link_flags}
+// RUN: %{cxx} -c "%s" -o "%t.first.o" %{flags} %{compile_flags}
+// RUN: %{cxx} -c "%s" -o "%t.second.o" -DWITH_MAIN %{flags} %{compile_flags}
+// RUN: %{cxx} -o "%t.exe" "%t.first.o" "%t.second.o" %{flags} %{link_flags}
 // RUN: %{run}
 
 // GCC 5 pretends it supports C++17 features, but some features like static_assert
 // without a message are not actually supported. This causes some headers to fail
 // when included.
 // UNSUPPORTED: gcc-5 && c++17
 
 // Prevent <ext/hash_map> from generating deprecated warnings for this test.

libcxx/test/libcxx/gdb/gdb_pretty_printer_test.sh.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: host-has-gdb
 // UNSUPPORTED: libcpp-has-no-localization
 // UNSUPPORTED: c++03
 
-// RUN: %{cxx} %{flags} %s -o %t.exe %{compile_flags} -g %{link_flags}
+// RUN: %{cxx} %{flags} "%s" -o "%t.exe" %{compile_flags} -g %{link_flags}
 // Ensure locale-independence for unicode tests.
-// RUN: %{gdb} -nx -batch -iex "set autoload off" -ex "source %S/../../../utils/gdb/libcxx/printers.py" -ex "python register_libcxx_printer_loader()" -ex "source %S/gdb_pretty_printer_test.py" %t.exe
+// RUN: %{gdb} -nx -batch -iex "set autoload off" -ex "source %S/../../../utils/gdb/libcxx/printers.py" -ex "python register_libcxx_printer_loader()" -ex "source %S/gdb_pretty_printer_test.py" "%t.exe"
 
 #include <bitset>
 #include <deque>
 #include <list>
 #include <map>
 #include <memory>
 #include <queue>
 #include <set>

libcxx/test/libcxx/include_as_c.sh.cpp

 // file as C, but we're passing C++ flags on the command-line.
 // UNSUPPORTED: gcc
 
 // Test that the C wrapper headers can be included when compiling them as C.
 
 // NOTE: It's not common or recommended to have libc++ in the header search
 // path when compiling C files, but it does happen often enough.
 
-// RUN: %{cxx} -c -xc %s -fsyntax-only %{flags} %{compile_flags} -std=c99
+// RUN: %{cxx} -c -xc "%s" -fsyntax-only %{flags} %{compile_flags} -std=c99
 
 #include <__config>
 
 #include <complex.h>
 #include <ctype.h>
 #include <errno.h>
 #include <fenv.h>
 #include <float.h>

libcxx/test/libcxx/input.output/filesystems/class.directory_entry/directory_entry.mods/last_write_time.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
-// ADDITIONAL_COMPILE_FLAGS: -I %S/../../../../../../src/filesystem
+// ADDITIONAL_COMPILE_FLAGS: -I "%S/../../../../../../src/filesystem"
 
 // <filesystem>
 
 // class directory_entry
 
 #include "filesystem_include.h"
 #include <type_traits>
 #include <cassert>

libcxx/test/libcxx/input.output/filesystems/convert_file_time.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11
 // UNSUPPORTED: gcc-5
 
 // <filesystem>
 
 // typedef TrivialClock file_time_type;
 
-// ADDITIONAL_COMPILE_FLAGS: -I %S/../../../../src/filesystem
+// ADDITIONAL_COMPILE_FLAGS: -I "%S/../../../../src/filesystem"
 
 #include <filesystem>
 #include <chrono>
 #include <type_traits>
 #include <limits>
 #include <cstddef>
 #include <cassert>
 

libcxx/test/libcxx/language.support/support.rtti/type.info/type_info.comparison.merged.sh.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-rtti
 
-// RUN: %{cxx} %s %{flags} %{compile_flags} -c -o %t.tu1.o -DTU1 -D_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION=1
-// RUN: %{cxx} %s %{flags} %{compile_flags} -c -o %t.tu2.o -DTU2 -D_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION=1
-// RUN: %{cxx} %s %{flags} %{compile_flags} -c -o %t.main.o -DMAIN -D_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION=1
-// RUN: %{cxx} %t.tu1.o %t.tu2.o %t.main.o %{flags} %{link_flags} -o %t.exe
-// RUN: %{exec} %t.exe
+// RUN: %{cxx} "%s" %{flags} %{compile_flags} -c -o "%t.tu1.o" -DTU1 -D_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION=1
+// RUN: %{cxx} "%s" %{flags} %{compile_flags} -c -o "%t.tu2.o" -DTU2 -D_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION=1
+// RUN: %{cxx} "%s" %{flags} %{compile_flags} -c -o "%t.main.o" -DMAIN -D_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION=1
+// RUN: %{cxx} "%t.tu1.o" "%t.tu2.o" "%t.main.o" %{flags} %{link_flags} -o "%t.exe"
+// RUN: %{exec} "%t.exe"
 
 #include <cassert>
 #include <typeindex>
 #include <vector>
 
 extern std::vector<std::type_index> registry;
 
 void register1();

libcxx/test/libcxx/language.support/support.rtti/type.info/type_info.comparison.unmerged.sh.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: no-rtti
 
-// RUN: %{cxx} %s %{flags} %{compile_flags} -c -o %t.tu1.o -DTU1 -D_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION=2
-// RUN: %{cxx} %s %{flags} %{compile_flags} -c -o %t.tu2.o -DTU2 -D_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION=2
-// RUN: %{cxx} %s %{flags} %{compile_flags} -c -o %t.main.o -DMAIN -D_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION=2
-// RUN: %{cxx} %t.tu1.o %t.tu2.o %t.main.o %{flags} %{link_flags} -o %t.exe
-// RUN: %{exec} %t.exe
+// RUN: %{cxx} "%s" %{flags} %{compile_flags} -c -o "%t.tu1.o" -DTU1 -D_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION=2
+// RUN: %{cxx} "%s" %{flags} %{compile_flags} -c -o "%t.tu2.o" -DTU2 -D_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION=2
+// RUN: %{cxx} "%s" %{flags} %{compile_flags} -c -o "%t.main.o" -DMAIN -D_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION=2
+// RUN: %{cxx} "%t.tu1.o" "%t.tu2.o" "%t.main.o" %{flags} %{link_flags} -o "%t.exe"
+// RUN: %{exec} "%t.exe"
 
 #include <cassert>
 #include <typeindex>
 #include <vector>
 
 extern std::vector<std::type_index> registry;
 
 void register1();

libcxx/test/libcxx/libcpp_freestanding.sh.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Test that _LIBCPP_FREESTANDING is not defined when -ffreestanding is not passed
 // to the compiler but defined when -ffreestanding is passed to the compiler.
 
-// RUN: %{cxx} %{flags} %{compile_flags} -fsyntax-only %s
-// RUN: %{cxx} %{flags} %{compile_flags} -fsyntax-only -ffreestanding -DFREESTANDING %s
+// RUN: %{cxx} %{flags} %{compile_flags} -fsyntax-only "%s"
+// RUN: %{cxx} %{flags} %{compile_flags} -fsyntax-only -ffreestanding -DFREESTANDING "%s"
 
 #include <__config>
 
 #if defined(FREESTANDING) != defined(_LIBCPP_FREESTANDING)
 #error _LIBCPP_FREESTANDING should be defined in freestanding mode and not \
        defined in non-freestanding mode
 #endif

libcxx/test/libcxx/modules/stds_include.sh.cpp

 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: libcpp-has-no-localization
 
 // REQUIRES: modules-support
 
 // NOTE: The -std=XXX flag is present in %{flags}, so we overwrite it by passing it after %{flags}.
 // FIXME: Remove the `-DINVALIDATE_CACHE_FOO` macros. Their purpose is to workaround a bug in older Clang versions
 //        the same modules caches were reused across standard dialects.
-// RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++03 -DINVALIDATE_CACHE_CXX03 %s
-// RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++11 -DINVALIDATE_CACHE_CXX11 %s
-// RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++14 -DINVALIDATE_CACHE_CKK14 %s
-// RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++17 -DINVALIDATE_CACHE_CXX17 %s
-// RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++2a -DINVALIDATE_CACHE_CXX2A %s
+// RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++03 -DINVALIDATE_CACHE_CXX03 "%s"
+// RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++11 -DINVALIDATE_CACHE_CXX11 "%s"
+// RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++14 -DINVALIDATE_CACHE_CKK14 "%s"
+// RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++17 -DINVALIDATE_CACHE_CXX17 "%s"
+// RUN: %{cxx} %{flags} %{compile_flags} -fmodules -fcxx-modules -fsyntax-only -std=c++2a -DINVALIDATE_CACHE_CXX2A "%s"
 
 #include <vector>
 
 int main(int, char**) {
   return 0;
 }

libcxx/test/libcxx/selftest/dsl/dsl.sh.py

 #===----------------------------------------------------------------------===##
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===----------------------------------------------------------------------===##
 
 # Note: We prepend arguments with 'x' to avoid thinking there are too few
 #       arguments in case an argument is an empty string.
-# RUN: %{python} %s x%S \
-# RUN:              x%T \
+# RUN: %{python} "%s" "x%S" \
+# RUN:              "x%T" \
 # RUN:              x%{escaped_exec} \
 # RUN:              x%{escaped_cxx} \
 # RUN:              x%{escaped_flags} \
 # RUN:              x%{escaped_compile_flags} \
 # RUN:              x%{escaped_link_flags}
 # END.
 
 import base64

libcxx/test/libcxx/selftest/file_dependencies/absolute-and-relative-paths.sh.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Make sure that FILE_DEPENDENCIES work with relative AND absolute paths.
 
-// FILE_DEPENDENCIES: %S/a.txt
-// RUN: test -e %T/a.txt
+// FILE_DEPENDENCIES: "%S/a.txt"
+// RUN: test -e "%T/a.txt"
 
 // FILE_DEPENDENCIES: dir/b.txt
-// RUN: test -e %T/b.txt
+// RUN: test -e "%T/b.txt"

libcxx/test/libcxx/selftest/file_dependencies/substitute-in-dependencies.sh.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Make sure that lit substitutions are expanded inside FILE_DEPENDENCIES lines.
 
-// FILE_DEPENDENCIES: %s
-// RUN: test -e %T/substitute-in-dependencies.sh.cpp
+// FILE_DEPENDENCIES: "%s"
+// RUN: test -e "%T/substitute-in-dependencies.sh.cpp"

libcxx/test/libcxx/selftest/remote-substitutions.sh.cpp

 // effectively. This somewhat difficult-to-understand test checks that when
 // we run with a remote executor, test-executables are copied to the remote
 // host and their path is fixed up (directly in the command-line) to their
 // path on the remote host instead of the local host.
 //
 // We also check that the path of test-executables is replaced whether they
 // appear first in the command-line or not.
 
-// RUN: %{cxx} %s %{flags} %{compile_flags} %{link_flags} -o %t.exe
-// RUN: %{exec} %t.exe 0
-// RUN: %{exec} bash -c '! %t.exe 1'
+// RUN: %{cxx} "%s" %{flags} %{compile_flags} %{link_flags} -o "%t.exe"
+// RUN: %{exec} "%t.exe" 0
+// RUN: %{exec} bash -c '! "%t.exe" 1'
 
 #include <cassert>
 #include <cstdlib>
 
 int main(int argc, char** argv) {
   assert(argc == 2);
   int ret = std::atoi(argv[1]);
   return ret;
 }

libcxx/test/libcxx/selftest/sh.cpp/substitutions.sh.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Make sure we have access to the following substitutions at all times:
 // - %{cxx}
 // - %{flags}
 // - %{compile_flags}
 // - %{link_flags}
 // - %{exec}
 
-// RUN: %{cxx} %s %{flags} %{compile_flags} %{link_flags} -o %t.exe
-// RUN: %{exec} %t.exe "HELLO"
+// RUN: %{cxx} "%s" %{flags} %{compile_flags} %{link_flags} -o "%t.exe"
+// RUN: %{exec} "%t.exe" "HELLO"
 
 #include <cassert>
 #include <string>
 
 int main(int argc, char** argv) {
   assert(argc == 2);
 
   std::string arg = argv[1];
   assert(arg == "HELLO");
   return 0;
 }

libcxx/test/libcxx/selftest/tmpdir-exists.sh.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Make sure that the directory represented by %T exists when we run the test.
 
-// RUN: test -d %T
+// RUN: test -d "%T"

libcxx/test/libcxx/strings/basic.string/PR42676.sh.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Regression test for PR42676.
 
-// RUN: %{cxx} %{flags} %s -o %t.exe %{compile_flags} %{link_flags} -D_LIBCPP_HIDE_FROM_ABI_PER_TU
+// RUN: %{cxx} %{flags} "%s" -o "%t.exe" %{compile_flags} %{link_flags} -D_LIBCPP_HIDE_FROM_ABI_PER_TU
 // RUN: %{run}
 
 #include <memory>
 #include <string>
 
 int main(int, char**) {
     std::string s1(10u, '-', std::allocator<char>()); (void)s1;
     std::string s2("hello", std::allocator<char>()); (void)s2;
     std::string s3("hello"); (void)s3;
     return 0;
 }

libcxx/test/libcxx/utilities/function.objects/abi_bug_cxx03_cxx11_example.sh.cpp

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: clang || apple-clang
 // XFAIL: *
 
 // This tests is meant to demonstrate an existing ABI bug between the
 // C++03 and C++11 implementations of std::function. It is not a real test.
 
-// RUN: %{cxx} -c %s -o %t.first.o %{flags} %{compile_flags} -std=c++03 -g
-// RUN: %{cxx} -c %s -o %t.second.o -DWITH_MAIN %{flags} %{compile_flags} -g -std=c++11
-// RUN: %{cxx} -o %t.exe %t.first.o %t.second.o %{flags} %{link_flags} -g
+// RUN: %{cxx} -c "%s" -o "%t.first.o" %{flags} %{compile_flags} -std=c++03 -g
+// RUN: %{cxx} -c "%s" -o "%t.second.o" -DWITH_MAIN %{flags} %{compile_flags} -g -std=c++11
+// RUN: %{cxx} -o "%t.exe" "%t.first.o" "%t.second.o" %{flags} %{link_flags} -g
 // RUN: %{run}
 
 #include <functional>
 #include <cassert>
 
 typedef std::function<void(int)> Func;
 
 Func CreateFunc();

libcxx/test/libcxx/utilities/meta/stress_tests/stress_test_is_same.sh.cpp

 // The table below compares the compile time and object size for each of the
 // variants listed in the RUN script.
 //
 //  Impl          Compile Time    Object Size
 // -------------------------------------------
 // std::_IsSame:    689.634 ms     356 K
 // std::is_same:  8,129.180 ms     560 K
 //
-// RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %S/orig.o -ggdb  -ggnu-pubnames -ftemplate-depth=5000 -ftime-trace -std=c++17
-// RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %S/new.o -ggdb  -ggnu-pubnames -ftemplate-depth=5000 -ftime-trace -std=c++17 -DTEST_NEW
+// RUN: %{cxx} %{flags} %{compile_flags} -c "%s" -o "%S/orig.o" -ggdb  -ggnu-pubnames -ftemplate-depth=5000 -ftime-trace -std=c++17
+// RUN: %{cxx} %{flags} %{compile_flags} -c "%s" -o "%S/new.o" -ggdb  -ggnu-pubnames -ftemplate-depth=5000 -ftime-trace -std=c++17 -DTEST_NEW
 
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "template_cost_testing.h"
 
 template <int N> struct Arg { enum { value = 1 }; };

libcxx/test/libcxx/utilities/meta/stress_tests/stress_test_metafunctions.sh.cpp

 //
 //  Impl          Compile Time    Object Size
 // -------------------------------------------
 // _And:         3,498.639 ms     158 M
 // __lazy_and:  10,138.982 ms     334 M
 // __and_:      14,181.851 ms     648 M
 //
 
-// RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %S/new.o -ggdb  -ggnu-pubnames -ftemplate-depth=5000 -ftime-trace -std=c++17
-// RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %S/lazy.o -ggdb  -ggnu-pubnames -ftemplate-depth=5000 -ftime-trace  -std=c++17 -DTEST_LAZY_AND
-// RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %S/std.o -ggdb  -ggnu-pubnames -ftemplate-depth=5000 -ftime-trace   -std=c++17 -DTEST_STD_AND
+// RUN: %{cxx} %{flags} %{compile_flags} -c "%s" -o "%S/new.o" -ggdb  -ggnu-pubnames -ftemplate-depth=5000 -ftime-trace -std=c++17
+// RUN: %{cxx} %{flags} %{compile_flags} -c "%s" -o "%S/lazy.o" -ggdb  -ggnu-pubnames -ftemplate-depth=5000 -ftime-trace  -std=c++17 -DTEST_LAZY_AND
+// RUN: %{cxx} %{flags} %{compile_flags} -c "%s" -o "%S/std.o" -ggdb  -ggnu-pubnames -ftemplate-depth=5000 -ftime-trace   -std=c++17 -DTEST_STD_AND
 
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "template_cost_testing.h"
 using std::true_type;
 using std::false_type;

libcxx/test/libcxx/utilities/meta/stress_tests/stress_test_variant_overloads_impl.sh.cpp

 // -----------------------------------------------------
 // flat:              959 ms        792 KiB
 // recursive:      23,444 ms     23,000 KiB
 // -----------------------------------------------------
 // variant_old:    16,894 ms     17,000 KiB
 // variant_new:     1,105 ms        828 KiB
 
 
-// RUN: %{cxx} %{flags} %{compile_flags} -std=c++17 -c %s \
+// RUN: %{cxx} %{flags} %{compile_flags} -std=c++17 -c "%s" \
 // RUN:    -ggdb  -ggnu-pubnames -ftemplate-depth=5000 -ftime-trace -g \
-// RUN:    -DTEST_NS=flat_impl -o %S/flat.o
-// RUN: %{cxx} %{flags} %{compile_flags} -std=c++17 -c %s \
+// RUN:    -DTEST_NS=flat_impl -o "%S/flat.o"
+// RUN: %{cxx} %{flags} %{compile_flags} -std=c++17 -c "%s" \
 // RUN:    -ggdb  -ggnu-pubnames -ftemplate-depth=5000 -ftime-trace -g \
-// RUN:    -DTEST_NS=rec_impl -o %S/rec.o
-// RUN: %{cxx} %{flags} %{compile_flags} -std=c++17 -c %s \
+// RUN:    -DTEST_NS=rec_impl -o "%S/rec.o"
+// RUN: %{cxx} %{flags} %{compile_flags} -std=c++17 -c "%s" \
 // RUN:    -ggdb  -ggnu-pubnames -ftemplate-depth=5000 -ftime-trace -g \
-// RUN:    -DTEST_NS=variant_impl -o %S/variant.o
+// RUN:    -DTEST_NS=variant_impl -o "%S/variant.o"
 
 #include <type_traits>
 #include <tuple>
 #include <cassert>
 #include <variant>
 
 #include "test_macros.h"
 #include "template_cost_testing.h"

libcxx/test/std/input.output/iostream.objects/check-stderr.sh

 program=${1}
 expected_stderr=${2}
-${program} 2>stderr.log >stdout.log
+"${program}" 2>stderr.log >stdout.log
 [ "${expected_stderr}" == "$(cat stderr.log)" ]

libcxx/test/std/input.output/iostream.objects/check-stdout.sh

 program=${1}
 expected_stdout=${2}
-${program} 2>stderr.log >stdout.log
+"${program}" 2>stderr.log >stdout.log
 [ "${expected_stdout}" == "$(cat stdout.log)" ]

libcxx/test/std/input.output/iostream.objects/send-stdin.sh

 program=${1}
 input=${2}
-echo -n ${input} | ${program}
+echo -n ${input} | "${program}"

libcxx/test/std/namespace/addressable_functions.sh.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Make sure functions specified as being 'addressable' (their address can be
 // taken in a well-defined manner) are indeed addressable. This notion was
 // added by http://wg21.link/p0551. While it was technically only introduced
 // in C++20, we test it in all standard modes because it's basic QOI to provide
 // a consistent behavior for that across standard modes.
 
-// RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %t.tu1.o -DTU1
-// RUN: %{cxx} %{flags} %{compile_flags} -c %s -o %t.tu2.o -DTU2
-// RUN: %{cxx} %t.tu1.o %t.tu2.o %{flags} %{link_flags} -o %t.exe
-// RUN: %{exec} %t.exe
+// RUN: %{cxx} %{flags} %{compile_flags} -c "%s" -o "%t.tu1.o" -DTU1
+// RUN: %{cxx} %{flags} %{compile_flags} -c "%s" -o "%t.tu2.o" -DTU2
+// RUN: %{cxx} "%t.tu1.o" "%t.tu2.o" %{flags} %{link_flags} -o "%t.exe"
+// RUN: %{exec} "%t.exe"
 
 // The functions checked below come from <iostream> & friends
 // UNSUPPORTED: libcpp-has-no-localization
 
 #include <cassert>
 #include <ios>
 #include <istream>
 #include <map>

libcxx/utils/libcxx/test/config.py

def configure_substitutions(self):
         compile_flags = self.cxx.compile_flags + (self.cxx.warning_flags if self.cxx.use_warnings else [])
         sub.append(('%{flags}',         ' '.join(map(pipes.quote, flags))))
         sub.append(('%{compile_flags}', ' '.join(map(pipes.quote, compile_flags))))
         sub.append(('%{link_flags}',    ' '.join(map(pipes.quote, self.cxx.link_flags))))
         sub.append(('%{link_libcxxabi}', pipes.quote(self.cxx.link_libcxxabi_flag)))
         codesign_ident = self.get_lit_conf('llvm_codesign_identity', '')
         env_vars = ' '.join('%s=%s' % (k, pipes.quote(v)) for (k, v) in self.exec_env.items())
         exec_args = [
-            '--execdir %T',
+            '--execdir "%T"',
             '--codesign_identity "{}"'.format(codesign_ident),
             '--env {}'.format(env_vars)
         ]
         sub.append(('%{exec}', '{} {} -- '.format(self.executor, ' '.join(exec_args))))
 
     def configure_triple(self):
         # Get or infer the target triple.
         target_triple = self.get_lit_conf('target_triple')

libcxx/utils/libcxx/test/dsl.py

def sourceBuilds(config, source):
 
   This is done by compiling and linking a program that consists of the given
   source with the %{cxx} substitution, and seeing whether that succeeds.
   """
   with _makeConfigTest(config) as test:
     with open(test.getSourcePath(), 'w') as sourceFile:
       sourceFile.write(source)
     out, err, exitCode, timeoutInfo = _executeScriptInternal(test, ['%{build}'])
-    _executeScriptInternal(test, ['rm %t.exe'])
+    _executeScriptInternal(test, ['rm "%t.exe"'])
     return exitCode == 0
 
 @_memoizeExpensiveOperation(lambda c, p, args=None, testPrefix='': (c.substitutions, c.environment, p, args))
 def programOutput(config, program, args=None, testPrefix=''):
   """
   Compiles a program for the test target, run it on the test target and return
   the output.
 
try:
       if exitCode != 0:
         return None
 
       actualOut = re.search("command output:\n(.+)\n$", out, flags=re.DOTALL)
       actualOut = actualOut.group(1) if actualOut else ""
       return actualOut
 
     finally:
-      _executeScriptInternal(test, ['rm %t.exe'])
+      _executeScriptInternal(test, ['rm "%t.exe"'])
 
 @_memoizeExpensiveOperation(lambda c, f: (c.substitutions, c.environment, f))
 def hasCompileFlag(config, flag):
   """
   Return whether the compiler in the configuration supports a given compiler flag.
 
   This is done by executing the %{cxx} substitution with the given flag and
   checking whether that succeeds.
def compilerMacros(config, flags=''):
   be added to the compiler invocation when generating the macros.
   """
   with _makeConfigTest(config) as test:
     with open(test.getSourcePath(), 'w') as sourceFile:
       # Make sure files like <__config> are included, since they can define
       # additional macros.
       sourceFile.write("#include <cstddef>")
     unparsedOutput, err, exitCode, timeoutInfo = _executeScriptInternal(test, [
-      "%{{cxx}} %s -dM -E %{{flags}} %{{compile_flags}} {}".format(flags)
+      "%{{cxx}} \"%s\" -dM -E %{{flags}} %{{compile_flags}} {}".format(flags)
     ])
     parsedMacros = dict()
     defines = (l.strip() for l in unparsedOutput.split('\n') if l.startswith('#define '))
     for line in defines:
       line = line[len('#define '):]
       macro, _, value = line.partition(' ')
       parsedMacros[macro] = value
     return parsedMacros

libcxx/utils/libcxx/test/features.py

DEFAULT_FEATURES = [
 
   # Note: We use a custom modules cache path to make sure that we don't reuse
   #       the default one, which can be shared across builds. This is important
   #       because we define macros in headers files, and a change in these macros
   #       doesn't seem to invalidate modules cache entries, which means we could
   #       build against now-invalid cached headers from a previous build.
   Feature(name='modules-support',
           when=lambda cfg: hasCompileFlag(cfg, '-fmodules'),
-          actions=lambda cfg: [AddCompileFlag('-fmodules-cache-path=%t/ModuleCache')]),
+          actions=lambda cfg: [AddCompileFlag('-fmodules-cache-path="%t/ModuleCache"')]),
 
   Feature(name='non-lockfree-atomics',
           when=lambda cfg: sourceBuilds(cfg, """
             #include <atomic>
             struct Large { int storage[100]; };
             std::atomic<Large> x;
             int main(int, char**) { return x.load(), x.is_lock_free(); }
           """)),

libcxx/utils/libcxx/test/format.py

def parseScript(test, preamble):
     # Get the default substitutions
     tmpDir, tmpBase = _getTempPaths(test)
     useExternalSh = True
     substitutions = lit.TestRunner.getDefaultSubstitutions(test, tmpDir, tmpBase,
                                                            normalize_slashes=useExternalSh)
 
     # Check base substitutions and add the %{build} and %{run} convenience substitutions
     _checkBaseSubstitutions(substitutions)
-    substitutions.append(('%{build}', '%{cxx} %s %{flags} %{compile_flags} %{link_flags} -o %t.exe'))
-    substitutions.append(('%{run}', '%{exec} %t.exe'))
+    substitutions.append(('%{build}', '%{cxx} "%s" %{flags} %{compile_flags} %{link_flags} -o "%t.exe"'))
+    substitutions.append(('%{run}', '%{exec} "%t.exe"'))
 
     # Parse the test file, including custom directives
     additionalCompileFlags = []
     fileDependencies = []
     parsers = [
         lit.TestRunner.IntegratedTestKeywordParser('FILE_DEPENDENCIES:',
                                                    lit.TestRunner.ParserKind.LIST,
                                                    initial_value=fileDependencies),
         lit.TestRunner.IntegratedTestKeywordParser('ADDITIONAL_COMPILE_FLAGS:',
                                                    lit.TestRunner.ParserKind.LIST,
                                                    initial_value=additionalCompileFlags)
     ]
 
     scriptInTest = lit.TestRunner.parseIntegratedTestScript(test, additional_parsers=parsers,
                                                             require_script=not preamble)
     if isinstance(scriptInTest, lit.Test.Result):
         return scriptInTest
 
     script = []
 
     # For each file dependency in FILE_DEPENDENCIES, inject a command to copy
     # that file to the execution directory. Execute the copy from %S to allow
     # relative paths from the test directory.
     for dep in fileDependencies:
-        script += ['%dbg(SETUP) cd %S && cp {} %T'.format(dep)]
+        script += ['%dbg(SETUP) cd "%S" && cp {} "%T"'.format(dep)]
     script += preamble
     script += scriptInTest
 
     # Add compile flags specified with ADDITIONAL_COMPILE_FLAGS.
     substitutions = [(s, x + ' ' + ' '.join(additionalCompileFlags)) if s == '%{compile_flags}'
                             else (s, x) for (s, x) in substitutions]
 
     # Perform substitutions in the script itself.
def execute(self, test, litConfig):
         if '-fmodules' in test.config.available_features and self._disableWithModules(test):
             return lit.Test.Result(lit.Test.UNSUPPORTED, 'Test {} is unsupported when modules are enabled')
 
         if re.search('[.]sh[.][^.]+$', filename):
             steps = [ ] # The steps are already in the script
             return self._executeShTest(test, litConfig, steps)
         elif filename.endswith('.compile.pass.cpp'):
             steps = [
-                "%dbg(COMPILED WITH) %{cxx} %s %{flags} %{compile_flags} -fsyntax-only"
+                "%dbg(COMPILED WITH) %{cxx} \"%s\" %{flags} %{compile_flags} -fsyntax-only"
             ]
             return self._executeShTest(test, litConfig, steps)
         elif filename.endswith('.compile.fail.cpp'):
             steps = [
-                "%dbg(COMPILED WITH) ! %{cxx} %s %{flags} %{compile_flags} -fsyntax-only"
+                "%dbg(COMPILED WITH) ! %{cxx} \"%s\" %{flags} %{compile_flags} -fsyntax-only"
             ]
             return self._executeShTest(test, litConfig, steps)
         elif filename.endswith('.link.pass.cpp'):
             steps = [
-                "%dbg(COMPILED WITH) %{cxx} %s %{flags} %{compile_flags} %{link_flags} -o %t.exe"
+                "%dbg(COMPILED WITH) %{cxx} \"%s\" %{flags} %{compile_flags} %{link_flags} -o \"%t.exe\""
             ]
             return self._executeShTest(test, litConfig, steps)
         elif filename.endswith('.link.fail.cpp'):
             steps = [
-                "%dbg(COMPILED WITH) %{cxx} %s %{flags} %{compile_flags} -c -o %t.o",
-                "%dbg(LINKED WITH) ! %{cxx} %t.o %{flags} %{link_flags} -o %t.exe"
+                "%dbg(COMPILED WITH) %{cxx} \"%s\" %{flags} %{compile_flags} -c -o \"%t.o\"",
+                "%dbg(LINKED WITH) ! %{cxx} \"%t.o\" %{flags} %{link_flags} -o \"%t.exe\""
             ]
             return self._executeShTest(test, litConfig, steps)
         elif filename.endswith('.verify.cpp'):
             if not supportsVerify:
                 return lit.Test.Result(lit.Test.UNSUPPORTED,
                     "Test {} requires support for Clang-verify, which isn't supported by the compiler".format(test.getFullName()))
             steps = [
                 # Note: Use -Wno-error to make sure all diagnostics are not treated as errors,
                 #       which doesn't make sense for clang-verify tests.
-                "%dbg(COMPILED WITH) %{{cxx}} %s %{{flags}} %{{compile_flags}} -fsyntax-only -Wno-error {}".format(VERIFY_FLAGS)
+                "%dbg(COMPILED WITH) %{{cxx}} \"%s\" %{{flags}} %{{compile_flags}} -fsyntax-only -Wno-error {}".format(VERIFY_FLAGS)
             ]
             return self._executeShTest(test, litConfig, steps)
         # Make sure to check these ones last, since they will match other
         # suffixes above too.
         elif filename.endswith('.pass.cpp') or filename.endswith('.pass.mm'):
             steps = [
-                "%dbg(COMPILED WITH) %{cxx} %s %{flags} %{compile_flags} %{link_flags} -o %t.exe",
-                "%dbg(EXECUTED AS) %{exec} %t.exe"
+                "%dbg(COMPILED WITH) %{cxx} \"%s\" %{flags} %{compile_flags} %{link_flags} -o \"%t.exe\"",
+                "%dbg(EXECUTED AS) %{exec} \"%t.exe\""
             ]
             return self._executeShTest(test, litConfig, steps)
         # This is like a .verify.cpp test when clang-verify is supported,
         # otherwise it's like a .compile.fail.cpp test. This is only provided
         # for backwards compatibility with the test suite.
         elif filename.endswith('.fail.cpp'):
             if supportsVerify:
                 steps = [
-                    "%dbg(COMPILED WITH) %{{cxx}} %s %{{flags}} %{{compile_flags}} -fsyntax-only -Wno-error {}".format(VERIFY_FLAGS)
+                    "%dbg(COMPILED WITH) %{{cxx}} \"%s\" %{{flags}} %{{compile_flags}} -fsyntax-only -Wno-error {}".format(VERIFY_FLAGS)
                 ]
             else:
                 steps = [
-                    "%dbg(COMPILED WITH) ! %{cxx} %s %{flags} %{compile_flags} -fsyntax-only"
+                    "%dbg(COMPILED WITH) ! %{cxx} \"%s\" %{flags} %{compile_flags} -fsyntax-only"
                 ]
             return self._executeShTest(test, litConfig, steps)
         else:
             return lit.Test.Result(lit.Test.UNRESOLVED, "Unknown test suffix for '{}'".format(filename))
 
     # Utility function to add compile flags in lit.local.cfg files.
     def addCompileFlags(self, config, *flags):
         string = ' '.join(flags)

libcxxabi/test/CMakeLists.txt

 pythonize_bool(LIBCXXABI_USE_LLVM_UNWINDER)
 pythonize_bool(LIBCXXABI_USE_COMPILER_RT)
 pythonize_bool(LIBCXXABI_BUILD_EXTERNAL_THREAD_LIBRARY)
 pythonize_bool(LIBCXX_ENABLE_PARALLEL_ALGORITHMS)
 pythonize_bool(LIBCXXABI_LINK_TESTS_WITH_SHARED_LIBCXX)
 pythonize_bool(LIBCXXABI_LINK_TESTS_WITH_SHARED_LIBCXXABI)
 set(LIBCXXABI_TARGET_INFO "libcxx.test.target_info.LocalTI" CACHE STRING
     "TargetInfo to use when setting up test environment.")
-set(LIBCXXABI_EXECUTOR "${Python3_EXECUTABLE} ${LIBCXXABI_LIBCXX_PATH}/utils/run.py" CACHE STRING
+set(LIBCXXABI_EXECUTOR "${Python3_EXECUTABLE} '${LIBCXXABI_LIBCXX_PATH}/utils/run.py'" CACHE STRING
     "Executor to use when running tests.")
 
 if (LIBCXXABI_ENABLE_SHARED)
   set(LIBCXXABI_TEST_DEPS cxxabi_shared)
 else()
   set(LIBCXXABI_TEST_DEPS cxxabi_static)
 endif()
 

libcxxabi/test/incomplete_type.sh.cpp

 
 // UNSUPPORTED: no-exceptions
 // UNSUPPORTED: no-rtti
 
 // NOTE: Link libc++abi explicitly and before libc++ so that libc++ doesn't drag
 // in the system libc++abi installation on OS X. (DYLD_LIBRARY_PATH is ignored
 // for shell tests because of Apple security features).
 
-// RUN: %{cxx} %{flags} %{compile_flags} -Wno-unreachable-code -c %s -o %t.one.o
-// RUN: %{cxx} %{flags} %{compile_flags} -Wno-unreachable-code -c %s -o %t.two.o -DTU_ONE
-// RUN: %{cxx} %{flags} %t.one.o %t.two.o %{link_libcxxabi} %{link_flags} -o %t.exe
-// RUN: %{exec} %t.exe
+// RUN: %{cxx} %{flags} %{compile_flags} -Wno-unreachable-code -c "%s" -o "%t.one.o"
+// RUN: %{cxx} %{flags} %{compile_flags} -Wno-unreachable-code -c "%s" -o "%t.two.o" -DTU_ONE
+// RUN: %{cxx} %{flags} "%t.one.o" "%t.two.o" %{link_libcxxabi} %{link_flags} -o "%t.exe"
+// RUN: %{exec} "%t.exe"
 
 #include <stdio.h>
 #include <cstring>
 #include <cassert>
 #include <typeinfo>
 
 // Check that the addresses of the typeinfo differ but still compare equal
 // via their NTBS.

libcxxabi/test/native/arm-linux-eabi/ttype-encoding-00.pass.sh.s

-@ RUN: %{cxx} %{flags} %{link_flags} %s -o %t.exe
-@ RUN: %t.exe
+@ RUN: %{cxx} %{flags} %{link_flags} "%s" -o "%t.exe"
+@ RUN: "%t.exe"
 @ UNSUPPORTED: no-exceptions
 
 @ PURPOSE: Check that 0x00 is a valid value for ttype encoding.  LLVM and
 @ GCC 4.6 are generating 0x00 as ttype encoding.  libc++abi should provide
 @ legacy support.
 
 @ NOTE:
 @

libcxxabi/test/native/arm-linux-eabi/ttype-encoding-90.pass.sh.s

-@ RUN: %{cxx} %{flags} %{link_flags} %s -o %t.exe
-@ RUN: %t.exe
+@ RUN: %{cxx} %{flags} %{link_flags} "%s" -o "%t.exe"
+@ RUN: "%t.exe"
 @ UNSUPPORTED: no-exceptions
 
 @ PURPOSE: Check that 0x90 is a valid value for ttype encoding.
 
 @ NOTE:
 @
 @ This file is generated from the following C++ source code and then change the
 @ `TType Encoding` to 0x90.