#!/usr/bin/env python3.8
# Copyright 2022 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Tests for rustc_remote_wrapper."""

import rustc_remote_wrapper

import argparse
import parameterized
import unittest

from parameterized import parameterized
from unittest import mock


class MainArgParseTests(unittest.TestCase):

    def testDefaults(self):
        args, forward = rustc_remote_wrapper.parse_main_args([])
        self.assertIsNone(args.help)
        self.assertFalse(args.dry_run)
        self.assertFalse(args.local)
        self.assertFalse(args.verbose)
        self.assertFalse(args.fsatrace)
        self.assertEqual(args.command, [])
        self.assertEqual(forward, [])

    @parameterized.expand(
        [
            (['-h'],),
            (['--help'],),
            (['--help', '--local'],),
            (['--local', '--help'],),
            (['--local', '--help', '--', 'echo', 'ekko'],),
        ])
    def testHelp(self, flags):
        args, forward = rustc_remote_wrapper.parse_main_args(flags)
        self.assertIsNotNone(args.help)
        # don't care about other fields

    def testDefaultOpposites(self):
        args, forward = rustc_remote_wrapper.parse_main_args(
            [
                '--dry-run', '--local', '--verbose', '--fsatrace', '--',
                'rustc', 'src/lib.rs'
            ])
        self.assertIsNone(args.help)
        self.assertTrue(args.dry_run)
        self.assertTrue(args.local)
        self.assertTrue(args.verbose)
        self.assertTrue(args.fsatrace)
        self.assertEqual(args.command, ['rustc', 'src/lib.rs'])
        self.assertEqual(forward, [])

    def testForwardRewrapperArgs(self):
        args, forward = rustc_remote_wrapper.parse_main_args(
            [
                '--local', '--forward-me', 'arg1', '--forward-me=too',
                '--verbose', '--', 'rustc', 'src/lib.rs'
            ])
        self.assertIsNone(args.help)
        self.assertTrue(args.local)
        self.assertTrue(args.verbose)
        self.assertEqual(forward, ['--forward-me', 'arg1', '--forward-me=too'])
        self.assertEqual(args.command, ['rustc', 'src/lib.rs'])


class FilterCompileCommandTests(unittest.TestCase):

    def testDefaults(self):
        remote_params, filtered_command = rustc_remote_wrapper.filter_compile_command(
            [])
        self.assertFalse(remote_params.remote_disable)
        self.assertEqual(remote_params.remote_inputs, [])
        self.assertEqual(remote_params.remote_outputs, [])
        self.assertEqual(remote_params.remote_flags, [])
        self.assertEqual(filtered_command, [])

    def testNormalCommand(self):
        remote_params, filtered_command = rustc_remote_wrapper.filter_compile_command(
            ['echo', 'hello'])
        self.assertFalse(remote_params.remote_disable)
        self.assertEqual(remote_params.remote_inputs, [])
        self.assertEqual(remote_params.remote_outputs, [])
        self.assertEqual(remote_params.remote_flags, [])
        self.assertEqual(filtered_command, ['echo', 'hello'])

    def testRemoteDisable(self):
        remote_params, filtered_command = rustc_remote_wrapper.filter_compile_command(
            ['--remote-disable'])
        self.assertTrue(remote_params.remote_disable)
        self.assertEqual(filtered_command, [])

    def testRemoteInputs(self):
        remote_params, filtered_command = rustc_remote_wrapper.filter_compile_command(
            ['--remote-inputs', 'aaa,bbb'])
        self.assertEqual(remote_params.remote_inputs, 'aaa,bbb')
        self.assertEqual(filtered_command, [])

        remote_params, filtered_command = rustc_remote_wrapper.filter_compile_command(
            ['--remote-inputs=aaa,bbb'])
        self.assertEqual(remote_params.remote_inputs, 'aaa,bbb')
        self.assertEqual(filtered_command, [])

        remote_params, filtered_command = rustc_remote_wrapper.filter_compile_command(
            ['--remote-inputs', 'aaa', '--remote-inputs', 'bbb'])
        self.assertEqual(remote_params.remote_inputs, 'bbb')
        self.assertEqual(filtered_command, [])

    def testRemoteOutputs(self):
        remote_params, filtered_command = rustc_remote_wrapper.filter_compile_command(
            ['--remote-outputs', 'xxx,yyy'])
        self.assertEqual(remote_params.remote_outputs, 'xxx,yyy')
        self.assertEqual(filtered_command, [])

        remote_params, filtered_command = rustc_remote_wrapper.filter_compile_command(
            ['--remote-outputs=xxx,yyy'])
        self.assertEqual(remote_params.remote_outputs, 'xxx,yyy')
        self.assertEqual(filtered_command, [])

        remote_params, filtered_command = rustc_remote_wrapper.filter_compile_command(
            ['--remote-outputs', 'xxx', '--remote-outputs', 'yyy'])
        self.assertEqual(remote_params.remote_outputs, 'yyy')
        self.assertEqual(filtered_command, [])

    def testRemoteFlag(self):
        # argparse does not handle this:
        # remote_params = rustc_remote_wrapper.filter_compile_command(['--remote-flag', '--some-rewrapper-flag=foobar'])
        # self.assertEqual(remote_params.remote_flags, ['--some-rewrapper-flag=foobar'])

        remote_params, filtered_command = rustc_remote_wrapper.filter_compile_command(
            ['--remote-flag=--some-rewrapper-flag=foobar'])
        self.assertEqual(
            remote_params.remote_flags, ['--some-rewrapper-flag=foobar'])
        self.assertEqual(filtered_command, [])

        remote_params, filtered_command = rustc_remote_wrapper.filter_compile_command(
            ['--remote-flag=--some-rewrapper-flag=foobar', '--remote-flag=baz'])
        self.assertEqual(
            remote_params.remote_flags, ['--some-rewrapper-flag=foobar', 'baz'])
        self.assertEqual(filtered_command, [])

    @parameterized.expand(
        [
            # (input command, expected remote params, expected filtered command)
            (
                [],
                argparse.Namespace(
                    remote_disable=False,
                    remote_inputs=[],
                    remote_outputs=[],
                    remote_flags=[]),
                [],
            ),
            (
                ['make', 'it', 'so'],
                argparse.Namespace(
                    remote_disable=False,
                    remote_inputs=[],
                    remote_outputs=[],
                    remote_flags=[]),
                ['make', 'it', 'so'],
            ),
            (
                ['make', 'it', '--remote-disable', 'so'],
                argparse.Namespace(
                    remote_disable=True,
                    remote_inputs=[],
                    remote_outputs=[],
                    remote_flags=[]),
                ['make', 'it', 'so'],
            ),
            (
                ['make', '--remote-flag=--rewrapper-flag', 'it', 'so'],
                argparse.Namespace(
                    remote_disable=False,
                    remote_inputs=[],
                    remote_outputs=[],
                    remote_flags=['--rewrapper-flag']),
                ['make', 'it', 'so'],
            ),
            (
                ['make', '--remote-flag', '--rewrapper-flag', 'it', 'so'],
                argparse.Namespace(
                    remote_disable=False,
                    remote_inputs=[],
                    remote_outputs=[],
                    remote_flags=['--rewrapper-flag']),
                ['make', 'it', 'so'],
            ),
        ])
    def testGeneralCases(
            self, input_command, expected_remote_params,
            expected_filtered_command):
        remote_params, filtered_command = rustc_remote_wrapper.filter_compile_command(
            input_command)
        self.assertEqual(remote_params, expected_remote_params)
        self.assertEqual(filtered_command, expected_filtered_command)


class ApplyRemoteFlagsFromPseudoFlagsTests(unittest.TestCase):

    @parameterized.expand(
        [
            # (full command, expected value of .local)
            ([], False),
            (['--'], False),
            (['--local', '--'], True),
            (['--', '--remote-disable'], True),
        ])
    def testDefault(self, input_command, expected_local):
        main_config, rewrapper_opts = rustc_remote_wrapper.parse_main_args(
            input_command)
        remote_params, filtered_command = rustc_remote_wrapper.filter_compile_command(
            main_config.command)
        rustc_remote_wrapper.apply_remote_flags_from_pseudo_flags(
            main_config, remote_params)
        self.assertEqual(main_config.local, expected_local)


_ENV = rustc_remote_wrapper._ENV

_FAKE_GLOBALS = rustc_remote_wrapper._dependent_globals(
    '../../script.py', 'out/not-default')


class ParseRustCompileCommandTests(unittest.TestCase):

    def testEmpty(self):
        # Make sure degenerate case doesn't crash.
        self.assertEqual(
            rustc_remote_wrapper.parse_rust_compile_command([], _FAKE_GLOBALS),
            argparse.Namespace(
                depfile=None,
                dep_only_command=[_ENV],
                emit_llvm_ir=False,
                emit_llvm_bc=False,
                output=None,
                extra_filename='',
                target_triple='',
            ))

    @parameterized.expand(
        [
            (
                ['rustc', '--blah', '--emit=dep-info=foo/bar.d', '--bar=baz'],
                'foo/bar.d',
                [
                    _ENV, 'rustc', '--blah', '-Zbinary-dep-depinfo',
                    '--emit=dep-info=foo/bar.d.nolink', '--bar=baz'
                ],
            ),
            (  # with extra ./
                ['rustc', '--blah', '--emit=dep-info=./foo/bar.d', '--bar=baz'],
                'foo/bar.d',
                [
                    _ENV, 'rustc', '--blah', '-Zbinary-dep-depinfo',
                    '--emit=dep-info=foo/bar.d.nolink', '--bar=baz'
                ],
            ),
            (  # with link
                ['rustc', '--blah', '--emit=dep-info=foo/bar.d,link', '--bar=baz'],
                'foo/bar.d',
                [
                    _ENV, 'rustc', '--blah', '-Zbinary-dep-depinfo',
                    '--emit=dep-info=foo/bar.d.nolink', '--bar=baz'
                ],
            ),
            (  # with link
                ['rustc', '--blah', '--emit=link,dep-info=foo/bar.d', '--bar=baz'],
                'foo/bar.d',
                [
                    _ENV, 'rustc', '--blah', '-Zbinary-dep-depinfo',
                    '--emit=dep-info=foo/bar.d.nolink', '--bar=baz'
                ],
            ),
        ])
    def testRustCommandsWithDepInfo(
            self, command, expected_depfile, expected_dep_command):
        params = rustc_remote_wrapper.parse_rust_compile_command(
            command, _FAKE_GLOBALS)
        self.assertEqual(params.depfile, expected_depfile)
        self.assertEqual(params.dep_only_command, expected_dep_command)

    @parameterized.expand(
        [
            ('--emit=llvm-ir',),
            ('--emit=llvm-ir,link',),
            ('--emit=link,llvm-ir',),
            ('--emit=llvm-ir,dep-info=blah.d',),
            ('--emit=llvm-ir,llvm-bc',),
        ])
    def testEmitLLVMIR(self, flag):
        params = rustc_remote_wrapper.parse_rust_compile_command(
            ['rustc', 'ignored', flag, '--also-ignored'], _FAKE_GLOBALS)
        self.assertTrue(params.emit_llvm_ir)

    @parameterized.expand(
        [
            ('--emit=llvm-bc',),
            ('--emit=llvm-bc,link',),
            ('--emit=link,llvm-bc',),
            ('--emit=llvm-bc,dep-info=blah.d',),
            ('--emit=llvm-ir,llvm-bc',),
        ])
    def testEmitLLVMBC(self, flag):
        params = rustc_remote_wrapper.parse_rust_compile_command(
            ['rustc', 'ignored', flag, '--also-ignored'], _FAKE_GLOBALS)
        self.assertTrue(params.emit_llvm_bc)

    def testOutputFile(self):
        params = rustc_remote_wrapper.parse_rust_compile_command(
            ['rustc', '-o', 'path/to/output.rlib'], _FAKE_GLOBALS)
        self.assertEqual(params.output, 'path/to/output.rlib')

    def testOutputFileDotSlash(self):
        params = rustc_remote_wrapper.parse_rust_compile_command(
            ['rustc', '-o', './path/to/output.rlib'], _FAKE_GLOBALS)
        self.assertEqual(params.output, 'path/to/output.rlib')

    @parameterized.expand(
        [
            (['-Cextra-filename', 'feedface'], 'feedface'),
            (['-Cextra-filename=f00dface'], 'f00dface'),
        ])
    def testExtraFilename(self, flags, expected_name):
        command = ['rustc', 'ignored'] + flags + ['--also-ignored']
        params = rustc_remote_wrapper.parse_rust_compile_command(
            command, _FAKE_GLOBALS)
        self.assertEqual(params.extra_filename, expected_name)
        self.assertEqual(params.dep_only_command, [_ENV] + command)

    def testTargetTriple(self):
        command = ['rustc', '--target', 'powerpc-apple-darwin8']
        params = rustc_remote_wrapper.parse_rust_compile_command(
            command, _FAKE_GLOBALS)
        self.assertEqual(params.target_triple, 'powerpc-apple-darwin8')
        self.assertEqual(params.dep_only_command, [_ENV] + command)


if __name__ == '__main__':
    unittest.main()