# ===----------------------------------------------------------------------===##
#
# 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(__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)