# ===----------------------------------------------------------------------===##
#
# 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
#
# ===----------------------------------------------------------------------===##
# With picolibc, test_program_stderr_is_not_conflated_with_stdout fails
# because stdout & stderr are treated as the same.
# XFAIL: LIBCXX-PICOLIBC-FIXME
# 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 x%T x%{substitutions}
import base64
import copy
import os
import pickle
import platform
import subprocess
import sys
import unittest
from os.path import dirname
# Allow importing 'lit' and the 'libcxx' module. Make sure we put the lit
# path first so we don't find any system-installed version.
monorepoRoot = dirname(dirname(dirname(dirname(dirname(dirname(__file__))))))
sys.path = [
os.path.join(monorepoRoot, "libcxx", "utils"),
os.path.join(monorepoRoot, "llvm", "utils", "lit"),
] + sys.path
import libcxx.test.dsl as dsl
import lit.LitConfig
import lit.util
# Steal some parameters from the config running this test so that we can
# bootstrap our own TestingConfig.
args = list(map(lambda s: s[1:], sys.argv[1:8])) # Remove the leading 'x'
SOURCE_ROOT, EXEC_PATH, SUBSTITUTIONS = args
sys.argv[1:8] = []
# Decode the substitutions.
SUBSTITUTIONS = pickle.loads(base64.b64decode(SUBSTITUTIONS))
for s, sub in SUBSTITUTIONS:
print("Substitution '{}' is '{}'".format(s, sub))
class SetupConfigs(unittest.TestCase):
"""
Base class for the tests below -- it creates a fake TestingConfig.
"""
def setUp(self):
"""
Create a fake TestingConfig that can be populated however we wish for
the purpose of running unit tests below. We pre-populate it with the
minimum required substitutions.
"""
self.litConfig = lit.LitConfig.LitConfig(
progname="lit",
path=[],
quiet=False,
useValgrind=False,
valgrindLeakCheck=False,
valgrindArgs=[],
noExecute=False,
debug=False,
isWindows=platform.system() == "Windows",
order="smart",
params={},
)
self.config = lit.TestingConfig.TestingConfig.fromdefaults(self.litConfig)
self.config.environment = dict(os.environ)
self.config.test_source_root = SOURCE_ROOT
self.config.test_exec_root = EXEC_PATH
self.config.recursiveExpansionLimit = 10
self.config.substitutions = copy.deepcopy(SUBSTITUTIONS)
def getSubstitution(self, substitution):
"""
Return a given substitution from the TestingConfig. It is an error if
there is no such substitution.
"""
found = [x for (s, x) in self.config.substitutions if s == substitution]
assert len(found) == 1
return found[0]
def findIndex(list, pred):
"""Finds the index of the first element satisfying 'pred' in a list, or
'len(list)' if there is no such element."""
index = 0
for x in list:
if pred(x):
break
else:
index += 1
return index
class TestHasCompileFlag(SetupConfigs):
"""
Tests for libcxx.test.dsl.hasCompileFlag
"""
def test_no_flag_should_work(self):
self.assertTrue(dsl.hasCompileFlag(self.config, ""))
def test_flag_exists(self):
self.assertTrue(dsl.hasCompileFlag(self.config, "-O1"))
def test_nonexistent_flag(self):
self.assertFalse(
dsl.hasCompileFlag(self.config, "-this_is_not_a_flag_any_compiler_has")
)
def test_multiple_flags(self):
self.assertTrue(dsl.hasCompileFlag(self.config, "-O1 -Dhello"))
class TestSourceBuilds(SetupConfigs):
"""
Tests for libcxx.test.dsl.sourceBuilds
"""
def test_valid_program_builds(self):
source = """int main(int, char**) { return 0; }"""
self.assertTrue(dsl.sourceBuilds(self.config, source))
def test_compilation_error_fails(self):
source = """int main(int, char**) { this does not compile }"""
self.assertFalse(dsl.sourceBuilds(self.config, source))
def test_link_error_fails(self):
source = """extern void this_isnt_defined_anywhere();
int main(int, char**) { this_isnt_defined_anywhere(); return 0; }"""
self.assertFalse(dsl.sourceBuilds(self.config, source))
class TestProgramOutput(SetupConfigs):
"""
Tests for libcxx.test.dsl.programOutput
"""
def test_valid_program_returns_output(self):
source = """
#include <cstdio>
int main(int, char**) { std::printf("FOOBAR"); return 0; }
"""
self.assertEqual(dsl.programOutput(self.config, source), "FOOBAR")
def test_valid_program_returns_output_newline_handling(self):
source = """
#include <cstdio>
int main(int, char**) { std::printf("FOOBAR\\n"); return 0; }
"""
self.assertEqual(dsl.programOutput(self.config, source), "FOOBAR\n")
def test_valid_program_returns_no_output(self):
source = """
int main(int, char**) { return 0; }
"""
self.assertEqual(dsl.programOutput(self.config, source), "")
def test_program_that_fails_to_run_raises_runtime_error(self):
# The program compiles, but exits with an error
source = """
int main(int, char**) { return 1; }
"""
self.assertRaises(
dsl.ConfigurationRuntimeError,
lambda: dsl.programOutput(self.config, source),
)
def test_program_that_fails_to_compile_raises_compilation_error(self):
# The program doesn't compile
source = """
int main(int, char**) { this doesnt compile }
"""
self.assertRaises(
dsl.ConfigurationCompilationError,
lambda: dsl.programOutput(self.config, source),
)
def test_pass_arguments_to_program(self):
source = """
#include <cassert>
#include <string>
int main(int argc, char** argv) {
assert(argc == 3);
assert(argv[1] == std::string("first-argument"));
assert(argv[2] == std::string("second-argument"));
return 0;
}
"""
args = ["first-argument", "second-argument"]
self.assertEqual(dsl.programOutput(self.config, source, args=args), "")
def test_caching_is_not_too_aggressive(self):
# Run a program, then change the substitutions and run it again.
# Make sure the program is run the second time and the right result
# is given, to ensure we're not incorrectly caching the result of the
# first program run.
source = """
#include <cstdio>
int main(int, char**) {
std::printf("MACRO=%u\\n", MACRO);
return 0;
}
"""
compileFlagsIndex = findIndex(
self.config.substitutions, lambda x: x[0] == "%{compile_flags}"
)
compileFlags = self.config.substitutions[compileFlagsIndex][1]
self.config.substitutions[compileFlagsIndex] = (
"%{compile_flags}",
compileFlags + " -DMACRO=1",
)
output1 = dsl.programOutput(self.config, source)
self.assertEqual(output1, "MACRO=1\n")
self.config.substitutions[compileFlagsIndex] = (
"%{compile_flags}",
compileFlags + " -DMACRO=2",
)
output2 = dsl.programOutput(self.config, source)
self.assertEqual(output2, "MACRO=2\n")
def test_program_stderr_is_not_conflated_with_stdout(self):
# Run a program that produces stdout output and stderr output too, making
# sure the stderr output does not pollute the stdout output.
source = """
#include <cstdio>
int main(int, char**) {
std::fprintf(stdout, "STDOUT-OUTPUT");
std::fprintf(stderr, "STDERR-OUTPUT");
return 0;
}
"""
self.assertEqual(dsl.programOutput(self.config, source), "STDOUT-OUTPUT")
class TestProgramSucceeds(SetupConfigs):
"""
Tests for libcxx.test.dsl.programSucceeds
"""
def test_success(self):
source = """
int main(int, char**) { return 0; }
"""
self.assertTrue(dsl.programSucceeds(self.config, source))
def test_failure(self):
source = """
int main(int, char**) { return 1; }
"""
self.assertFalse(dsl.programSucceeds(self.config, source))
def test_compile_failure(self):
source = """
this does not compile
"""
self.assertRaises(
dsl.ConfigurationCompilationError,
lambda: dsl.programSucceeds(self.config, source),
)
class TestHasLocale(SetupConfigs):
"""
Tests for libcxx.test.dsl.hasLocale
"""
def test_doesnt_explode(self):
# It's really hard to test that a system has a given locale, so at least
# make sure we don't explode when we try to check it.
try:
dsl.hasAnyLocale(self.config, ["en_US.UTF-8"])
except subprocess.CalledProcessError:
self.fail("checking for hasLocale should not explode")
def test_nonexistent_locale(self):
self.assertFalse(
dsl.hasAnyLocale(self.config, ["forsurethisisnotanexistinglocale"])
)
def test_localization_program_doesnt_compile(self):
compilerIndex = findIndex(self.config.substitutions, lambda x: x[0] == "%{cxx}")
self.config.substitutions[compilerIndex] = (
"%{cxx}",
"this-is-certainly-not-a-valid-compiler!!",
)
self.assertRaises(
dsl.ConfigurationCompilationError,
lambda: dsl.hasAnyLocale(self.config, ["en_US.UTF-8"]),
)
class TestCompilerMacros(SetupConfigs):
"""
Tests for libcxx.test.dsl.compilerMacros
"""
def test_basic(self):
macros = dsl.compilerMacros(self.config)
self.assertIsInstance(macros, dict)
self.assertGreater(len(macros), 0)
for (k, v) in macros.items():
self.assertIsInstance(k, str)
self.assertIsInstance(v, str)
def test_no_flag(self):
macros = dsl.compilerMacros(self.config)
self.assertIn("__cplusplus", macros.keys())
def test_empty_flag(self):
macros = dsl.compilerMacros(self.config, "")
self.assertIn("__cplusplus", macros.keys())
def test_with_flag(self):
macros = dsl.compilerMacros(self.config, "-DFOO=3")
self.assertIn("__cplusplus", macros.keys())
self.assertEqual(macros["FOO"], "3")
def test_with_flags(self):
macros = dsl.compilerMacros(self.config, "-DFOO=3 -DBAR=hello")
self.assertIn("__cplusplus", macros.keys())
self.assertEqual(macros["FOO"], "3")
self.assertEqual(macros["BAR"], "hello")
class TestFeatureTestMacros(SetupConfigs):
"""
Tests for libcxx.test.dsl.featureTestMacros
"""
def test_basic(self):
macros = dsl.featureTestMacros(self.config)
self.assertIsInstance(macros, dict)
self.assertGreater(len(macros), 0)
for (k, v) in macros.items():
self.assertIsInstance(k, str)
self.assertIsInstance(v, int)
class TestFeature(SetupConfigs):
"""
Tests for libcxx.test.dsl.Feature
"""
def test_trivial(self):
feature = dsl.Feature(name="name")
origSubstitutions = copy.deepcopy(self.config.substitutions)
actions = feature.getActions(self.config)
self.assertTrue(len(actions) == 1)
for a in actions:
a.applyTo(self.config)
self.assertEqual(origSubstitutions, self.config.substitutions)
self.assertIn("name", self.config.available_features)
def test_name_can_be_a_callable(self):
feature = dsl.Feature(name=lambda cfg: "name")
for a in feature.getActions(self.config):
a.applyTo(self.config)
self.assertIn("name", self.config.available_features)
def test_name_is_not_a_string_1(self):
feature = dsl.Feature(name=None)
self.assertRaises(ValueError, lambda: feature.getActions(self.config))
self.assertRaises(ValueError, lambda: feature.pretty(self.config))
def test_name_is_not_a_string_2(self):
feature = dsl.Feature(name=lambda cfg: None)
self.assertRaises(ValueError, lambda: feature.getActions(self.config))
self.assertRaises(ValueError, lambda: feature.pretty(self.config))
def test_adding_action(self):
feature = dsl.Feature(name="name", actions=[dsl.AddCompileFlag("-std=c++03")])
origLinkFlags = copy.deepcopy(self.getSubstitution("%{link_flags}"))
for a in feature.getActions(self.config):
a.applyTo(self.config)
self.assertIn("name", self.config.available_features)
self.assertIn("-std=c++03", self.getSubstitution("%{compile_flags}"))
self.assertEqual(origLinkFlags, self.getSubstitution("%{link_flags}"))
def test_actions_can_be_a_callable(self):
feature = dsl.Feature(
name="name",
actions=lambda cfg: (
self.assertIs(self.config, cfg),
[dsl.AddCompileFlag("-std=c++03")],
)[1],
)
for a in feature.getActions(self.config):
a.applyTo(self.config)
self.assertIn("-std=c++03", self.getSubstitution("%{compile_flags}"))
def test_unsupported_feature(self):
feature = dsl.Feature(name="name", when=lambda _: False)
self.assertEqual(feature.getActions(self.config), [])
def test_is_supported_gets_passed_the_config(self):
feature = dsl.Feature(
name="name", when=lambda cfg: (self.assertIs(self.config, cfg), True)[1]
)
self.assertEqual(len(feature.getActions(self.config)), 1)
def _throw():
raise ValueError()
class TestParameter(SetupConfigs):
"""
Tests for libcxx.test.dsl.Parameter
"""
def test_empty_name_should_blow_up(self):
self.assertRaises(
ValueError,
lambda: dsl.Parameter(
name="", choices=["c++03"], type=str, help="", actions=lambda _: []
),
)
def test_empty_choices_should_blow_up(self):
self.assertRaises(
ValueError,
lambda: dsl.Parameter(
name="std", choices=[], type=str, help="", actions=lambda _: []
),
)
def test_no_choices_is_ok(self):
param = dsl.Parameter(name="triple", type=str, help="", actions=lambda _: [])
self.assertEqual(param.name, "triple")
def test_name_is_set_correctly(self):
param = dsl.Parameter(
name="std", choices=["c++03"], type=str, help="", actions=lambda _: []
)
self.assertEqual(param.name, "std")
def test_no_value_provided_and_no_default_value(self):
param = dsl.Parameter(
name="std", choices=["c++03"], type=str, help="", actions=lambda _: []
)
self.assertRaises(
ValueError, lambda: param.getActions(self.config, self.litConfig.params)
)
def test_no_value_provided_and_default_value(self):
param = dsl.Parameter(
name="std",
choices=["c++03"],
type=str,
help="",
default="c++03",
actions=lambda std: [dsl.AddFeature(std)],
)
for a in param.getActions(self.config, self.litConfig.params):
a.applyTo(self.config)
self.assertIn("c++03", self.config.available_features)
def test_value_provided_on_command_line_and_no_default_value(self):
self.litConfig.params["std"] = "c++03"
param = dsl.Parameter(
name="std",
choices=["c++03"],
type=str,
help="",
actions=lambda std: [dsl.AddFeature(std)],
)
for a in param.getActions(self.config, self.litConfig.params):
a.applyTo(self.config)
self.assertIn("c++03", self.config.available_features)
def test_value_provided_on_command_line_and_default_value(self):
"""The value provided on the command line should override the default value"""
self.litConfig.params["std"] = "c++11"
param = dsl.Parameter(
name="std",
choices=["c++03", "c++11"],
type=str,
default="c++03",
help="",
actions=lambda std: [dsl.AddFeature(std)],
)
for a in param.getActions(self.config, self.litConfig.params):
a.applyTo(self.config)
self.assertIn("c++11", self.config.available_features)
self.assertNotIn("c++03", self.config.available_features)
def test_value_provided_in_config_and_default_value(self):
"""The value provided in the config should override the default value"""
self.config.std = "c++11"
param = dsl.Parameter(
name="std",
choices=["c++03", "c++11"],
type=str,
default="c++03",
help="",
actions=lambda std: [dsl.AddFeature(std)],
)
for a in param.getActions(self.config, self.litConfig.params):
a.applyTo(self.config)
self.assertIn("c++11", self.config.available_features)
self.assertNotIn("c++03", self.config.available_features)
def test_value_provided_in_config_and_on_command_line(self):
"""The value on the command line should override the one in the config"""
self.config.std = "c++11"
self.litConfig.params["std"] = "c++03"
param = dsl.Parameter(
name="std",
choices=["c++03", "c++11"],
type=str,
help="",
actions=lambda std: [dsl.AddFeature(std)],
)
for a in param.getActions(self.config, self.litConfig.params):
a.applyTo(self.config)
self.assertIn("c++03", self.config.available_features)
self.assertNotIn("c++11", self.config.available_features)
def test_no_actions(self):
self.litConfig.params["std"] = "c++03"
param = dsl.Parameter(
name="std", choices=["c++03"], type=str, help="", actions=lambda _: []
)
actions = param.getActions(self.config, self.litConfig.params)
self.assertEqual(actions, [])
def test_boolean_value_parsed_from_trueish_string_parameter(self):
self.litConfig.params["enable_exceptions"] = "True"
param = dsl.Parameter(
name="enable_exceptions",
choices=[True, False],
type=bool,
help="",
actions=lambda exceptions: [] if exceptions else _throw(),
)
self.assertEqual(param.getActions(self.config, self.litConfig.params), [])
def test_boolean_value_from_true_boolean_parameter(self):
self.litConfig.params["enable_exceptions"] = True
param = dsl.Parameter(
name="enable_exceptions",
choices=[True, False],
type=bool,
help="",
actions=lambda exceptions: [] if exceptions else _throw(),
)
self.assertEqual(param.getActions(self.config, self.litConfig.params), [])
def test_boolean_value_parsed_from_falseish_string_parameter(self):
self.litConfig.params["enable_exceptions"] = "False"
param = dsl.Parameter(
name="enable_exceptions",
choices=[True, False],
type=bool,
help="",
actions=lambda exceptions: []
if exceptions
else [dsl.AddFeature("-fno-exceptions")],
)
for a in param.getActions(self.config, self.litConfig.params):
a.applyTo(self.config)
self.assertIn("-fno-exceptions", self.config.available_features)
def test_boolean_value_from_false_boolean_parameter(self):
self.litConfig.params["enable_exceptions"] = False
param = dsl.Parameter(
name="enable_exceptions",
choices=[True, False],
type=bool,
help="",
actions=lambda exceptions: []
if exceptions
else [dsl.AddFeature("-fno-exceptions")],
)
for a in param.getActions(self.config, self.litConfig.params):
a.applyTo(self.config)
self.assertIn("-fno-exceptions", self.config.available_features)
def test_list_parsed_from_comma_delimited_string_empty(self):
self.litConfig.params["additional_features"] = ""
param = dsl.Parameter(
name="additional_features", type=list, help="", actions=lambda f: f
)
self.assertEqual(param.getActions(self.config, self.litConfig.params), [])
def test_list_parsed_from_comma_delimited_string_1(self):
self.litConfig.params["additional_features"] = "feature1"
param = dsl.Parameter(
name="additional_features", type=list, help="", actions=lambda f: f
)
self.assertEqual(
param.getActions(self.config, self.litConfig.params), ["feature1"]
)
def test_list_parsed_from_comma_delimited_string_2(self):
self.litConfig.params["additional_features"] = "feature1,feature2"
param = dsl.Parameter(
name="additional_features", type=list, help="", actions=lambda f: f
)
self.assertEqual(
param.getActions(self.config, self.litConfig.params),
["feature1", "feature2"],
)
def test_list_parsed_from_comma_delimited_string_3(self):
self.litConfig.params["additional_features"] = "feature1,feature2, feature3"
param = dsl.Parameter(
name="additional_features", type=list, help="", actions=lambda f: f
)
self.assertEqual(
param.getActions(self.config, self.litConfig.params),
["feature1", "feature2", "feature3"],
)
if __name__ == "__main__":
unittest.main(verbosity=2)
Codebase Browser
llvm