def test_should_not_test_optimizations_when_testing_only_host(self):
        host_target = 'android-armv7'
        args = self.default_args()
        args.host_target = host_target
        args.build_android = True
        args.test_android = True
        args.stdlib_deployment_targets = [host_target]
        args.build_stdlib_deployment_targets = 'all'
        args.test_optimized = True
        args.test_optimize_for_size = True
        args.test_optimize_none_implicit_dynamic = True

        before = HostSpecificConfiguration(host_target, args)
        self.assertIn('check-swift-optimize-android-armv7',
                      before.swift_test_run_targets)
        self.assertIn('check-swift-optimize_size-android-armv7',
                      before.swift_test_run_targets)
        self.assertIn(
            'check-swift-optimize_none_implicit_dynamic-android-armv7',
            before.swift_test_run_targets)

        args.test_android_host = True
        after = HostSpecificConfiguration(host_target, args)
        self.assertNotIn('check-swift-optimize-android-armv7',
                         after.swift_test_run_targets)
        self.assertNotIn('check-swift-optimize_size-android-armv7',
                         after.swift_test_run_targets)
        self.assertNotIn(
            'check-swift-optimize_none_implicit_dynamic-android-armv7',
            after.swift_test_run_targets)
        def test(self):
            args = self.default_args()
            args.host_target = host_target
            args.stdlib_deployment_targets = [host_target]
            args.build_stdlib_deployment_targets = 'all'

            before = HostSpecificConfiguration(host_target, args)
            self.assertIn(sdk_name, before.sdks_to_configure)
            self.assertNotIn(build_target, before.swift_stdlib_build_targets)

            setattr(args, build_arg_name, True)
            after = HostSpecificConfiguration(host_target, args)
            self.assertIn(sdk_name, after.sdks_to_configure)
            self.assertIn(build_target, after.swift_stdlib_build_targets)
        def test(self):
            args = self.default_args()
            setattr(args, build_arg_name, True)
            args.host_target = host_target
            args.stdlib_deployment_targets = [host_target]
            args.build_stdlib_deployment_targets = 'all'

            before = HostSpecificConfiguration(host_target, args)
            self.assertEqual(len(before.swift_test_run_targets), 0)

            setattr(args, test_arg_name, True)
            after = HostSpecificConfiguration(host_target, args)
            self.assertIn('check-swift-{}'.format(host_target),
                          after.swift_test_run_targets)
        def test(self):
            args = self.default_args()
            setattr(args, build_arg_name, True)
            args.host_target = host_target
            args.stdlib_deployment_targets = [host_target]
            args.build_stdlib_deployment_targets = 'all'

            with_benchmark = HostSpecificConfiguration(host_target, args)
            self.assertIn('swift-benchmark-{}'.format(host_target),
                          with_benchmark.swift_benchmark_build_targets)
            self.assertNotIn('check-swift-benchmark-{}'.format(host_target),
                             with_benchmark.swift_benchmark_run_targets)

            args.benchmark = True
            running_benchmarks = HostSpecificConfiguration(host_target, args)
            self.assertIn('swift-benchmark-{}'.format(host_target),
                          running_benchmarks.swift_benchmark_build_targets)
            self.assertIn('check-swift-benchmark-{}'.format(host_target),
                          running_benchmarks.swift_benchmark_run_targets)

            args.build_external_benchmarks = True
            with_external_benchmarks = HostSpecificConfiguration(
                host_target, args)
            self.assertIn(
                'swift-benchmark-{}'.format(host_target),
                with_external_benchmarks.swift_benchmark_build_targets)
            self.assertIn(
                'swift-benchmark-{}-external'.format(host_target),
                with_external_benchmarks.swift_benchmark_build_targets)
            self.assertIn('check-swift-benchmark-{}'.format(host_target),
                          with_external_benchmarks.swift_benchmark_run_targets)
            self.assertIn(
                'check-swift-benchmark-{}-external'.format(host_target),
                with_external_benchmarks.swift_benchmark_run_targets)

            args.benchmark = False
            not_running_benchmarks = HostSpecificConfiguration(
                host_target, args)
            self.assertIn('swift-benchmark-{}'.format(host_target),
                          not_running_benchmarks.swift_benchmark_build_targets)
            self.assertIn('swift-benchmark-{}-external'.format(host_target),
                          not_running_benchmarks.swift_benchmark_build_targets)
            self.assertNotIn(
                'check-swift-benchmark-{}'.format(host_target),
                not_running_benchmarks.swift_benchmark_run_targets)
            self.assertNotIn(
                'check-swift-benchmark-{}-external'.format(host_target),
                not_running_benchmarks.swift_benchmark_run_targets)
    def test_should_allow_testing_only_executable_tests(self):
        args = self.default_args()
        args.build_osx = True
        args.test_osx = True
        args.host_target = 'macosx-x86_64'
        args.stdlib_deployment_targets = ['macosx-x86_64']
        args.build_stdlib_deployment_targets = 'all'

        before = HostSpecificConfiguration('macosx-x86_64', args)
        self.assertIn('check-swift-macosx-x86_64',
                      before.swift_test_run_targets)

        args.only_executable_test = True
        after = HostSpecificConfiguration('macosx-x86_64', args)
        self.assertIn('check-swift-only_executable-macosx-x86_64',
                      after.swift_test_run_targets)
    def test_should_skip_testing_32bit_ios(self):
        host_target = 'iphonesimulator-i386'
        args = self.default_args()
        args.build_ios_simulator = True
        args.test_ios_simulator = True
        args.host_target = host_target
        args.stdlib_deployment_targets = [host_target]
        args.build_stdlib_deployment_targets = 'all'

        before = HostSpecificConfiguration(host_target, args)
        self.assertEqual(len(before.swift_test_run_targets), 0)

        args.test_ios_32bit_simulator = True
        after = HostSpecificConfiguration(host_target, args)
        self.assertIn('check-swift-iphonesimulator-i386',
                      after.swift_test_run_targets)
        def test(self):
            host_target = 'macosx-x86_64'
            args = self.default_args()
            args.build_osx = True
            args.test_osx = True
            args.host_target = host_target
            args.stdlib_deployment_targets = [host_target]
            args.build_stdlib_deployment_targets = 'all'

            target = 'check-swift-{}-macosx-x86_64'.format(optimize_name)

            before = HostSpecificConfiguration(host_target, args)
            self.assertNotIn(target, before.swift_test_run_targets)

            setattr(args, optimize_arg_name, True)
            after = HostSpecificConfiguration(host_target, args)
            self.assertIn(target, after.swift_test_run_targets)
    def test_should_not_build_stdlib_when_targets_are_empty(self):
        args = self.default_args()
        args.host_target = 'macosx-x86_64'
        args.stdlib_deployment_targets = []

        hsc = HostSpecificConfiguration('macosx-arm64', args)

        self.assertEqual(len(hsc.sdks_to_configure), 0)

        self.assertEqual(len(hsc.swift_stdlib_build_targets), 0)
        def test(self):
            host_target = 'macosx-x86_64'
            args = self.default_args()
            args.build_osx = True
            args.host_target = host_target
            args.stdlib_deployment_targets = [host_target]
            args.build_stdlib_deployment_targets = 'all'

            before = HostSpecificConfiguration(host_target, args)
            self.assertIn('swift-test-stdlib-macosx-x86_64',
                          before.swift_stdlib_build_targets)
            self.assertNotIn('swift-stdlib-macosx-x86_64',
                             before.swift_stdlib_build_targets)

            setattr(args, test_arg_name, True)
            after = HostSpecificConfiguration(host_target, args)
            self.assertIn('swift-stdlib-macosx-x86_64',
                          after.swift_stdlib_build_targets)
            self.assertNotIn('swift-test-stdlib-macosx-x86_64',
                             after.swift_stdlib_build_targets)
    def test_should_only_configure_when_cross_compiling_different_stdlib_targets(self):
        args = self.default_args()
        args.build_ios_device = True
        args.host_target = 'macosx-x86_64'
        args.stdlib_deployment_targets = ['iphonesimulator-arm64']

        hsc = HostSpecificConfiguration('iphoneos-arm64', args)

        self.assertEqual(len(hsc.sdks_to_configure), 1)
        self.assertIn('IOS', hsc.sdks_to_configure)

        self.assertEqual(len(hsc.swift_stdlib_build_targets), 0)
    def test_should_configure_and_build_when_cross_compiling(self):
        args = self.default_args()
        args.build_ios_device = True
        args.host_target = 'macosx-x86_64'

        hsc = HostSpecificConfiguration('iphoneos-arm64', args)

        self.assertEqual(len(hsc.sdks_to_configure), 1)
        self.assertIn('IOS', hsc.sdks_to_configure)

        self.assertEqual(len(hsc.swift_stdlib_build_targets), 1)
        self.assertIn('swift-test-stdlib-iphoneos-arm64',
                      hsc.swift_stdlib_build_targets)
        def test(self):
            host_target = 'android-armv7'
            args = self.default_args()
            args.build_android = True
            args.test_android = True
            args.test_android_host = True
            args.host_target = host_target
            args.stdlib_deployment_targets = [host_target]
            args.build_stdlib_deployment_targets = 'all'

            all = 'check-swift-only_non_executable-android-armv7'
            subset = 'check-swift-{}-only_non_executable-android-armv7'\
                .format(subset_name)

            before = HostSpecificConfiguration(host_target, args)
            self.assertIn(all, before.swift_test_run_targets)
            self.assertNotIn(subset, before.swift_test_run_targets)

            setattr(args, subset_arg_name, True)
            after = HostSpecificConfiguration(host_target, args)
            self.assertIn(subset, after.swift_test_run_targets)
            self.assertNotIn(all, after.swift_test_run_targets)
    def test_should_test_all_when_validation_long_and_stress(self):
        host_target = 'macosx-x86_64'
        args = self.default_args()
        args.build_osx = True
        args.test_osx = True
        args.host_target = host_target
        args.stdlib_deployment_targets = [host_target]
        args.build_stdlib_deployment_targets = 'all'

        all = 'check-swift-macosx-x86_64'
        subset = 'check-swift-all-macosx-x86_64'

        before = HostSpecificConfiguration(host_target, args)
        self.assertIn(all, before.swift_test_run_targets)
        self.assertNotIn(subset, before.swift_test_run_targets)

        args.validation_test = True
        args.long_test = True
        args.stress_test = True
        after = HostSpecificConfiguration(host_target, args)
        self.assertIn(subset, after.swift_test_run_targets)
        self.assertNotIn(all, after.swift_test_run_targets)
    def test_should_test_all_when_validation_long_and_stress_with_host_only(
            self):
        host_target = 'android-armv7'
        args = self.default_args()
        args.build_android = True
        args.test_android = True
        args.test_android_host = True
        args.host_target = host_target
        args.stdlib_deployment_targets = [host_target]
        args.build_stdlib_deployment_targets = 'all'

        all = 'check-swift-only_non_executable-android-armv7'
        subset = 'check-swift-all-only_non_executable-android-armv7'

        before = HostSpecificConfiguration(host_target, args)
        self.assertIn(all, before.swift_test_run_targets)
        self.assertNotIn(subset, before.swift_test_run_targets)

        args.validation_test = True
        args.long_test = True
        args.stress_test = True
        after = HostSpecificConfiguration(host_target, args)
        self.assertIn(subset, after.swift_test_run_targets)
        self.assertNotIn(all, after.swift_test_run_targets)
    def test_should_only_deployment_if_specified(self):
        host_target = 'macosx-x86_64'
        args = self.default_args()
        args.build_osx = True
        args.build_ios_device = True
        args.host_target = host_target
        args.stdlib_deployment_targets = [host_target, 'iphoneos-arm64']
        args.build_stdlib_deployment_targets = ['iphoneos-arm64']

        hsc = HostSpecificConfiguration(host_target, args)

        self.assertEqual(len(hsc.sdks_to_configure), 2)
        self.assertIn('OSX', hsc.sdks_to_configure)
        self.assertIn('IOS', hsc.sdks_to_configure)

        self.assertEqual(len(hsc.swift_stdlib_build_targets), 1)
        self.assertIn('swift-test-stdlib-iphoneos-arm64',
                      hsc.swift_stdlib_build_targets)
    def test_should_test_optimizations_with_subsets(self):
        host_target = 'android-armv7'
        args = self.default_args()
        args.host_target = host_target
        args.build_android = True
        args.test_android = True
        args.stdlib_deployment_targets = [host_target]
        args.build_stdlib_deployment_targets = 'all'
        args.test_optimized = True
        args.test_optimize_for_size = True
        args.test_optimize_none_implicit_dynamic = True
        args.long_test = True

        target_name = 'check-swift-only_long-{}-android-armv7'

        before = HostSpecificConfiguration(host_target, args)
        self.assertIn(target_name.format('optimize'),
                      before.swift_test_run_targets)
        self.assertIn(target_name.format('optimize_size'),
                      before.swift_test_run_targets)
        self.assertIn(target_name.format('optimize_none_implicit_dynamic'),
                      before.swift_test_run_targets)