#!/usr/bin/python
#
# Copyright (c) 2011 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Unittest for generate_gn.py.

It's tough to test the lower-level GetSourceFiles() and GetObjectFiles()
functions, so this focuses on the higher-level functions assuming those two
functions are working as intended (i.e., producing lists of files).
"""

import generate_gn as gg
from generate_gn import SourceSet, SourceListCondition
import string
import unittest
from os import path


class ModuleUnittest(unittest.TestCase):

  def testGetObjectToSourceMapping(self):
    srcs = [
        'a.c',
        'b.asm',
        'c.cc',
    ]
    expected = {
        'a.o': 'a.c',
        'b.o': 'b.asm',
        'c.o': 'c.cc',
    }
    self.assertEqual(expected, gg.GetObjectToSourceMapping(srcs))

  def testGetSourceFileSet(self):
    objs_to_srcs = {
        'a.o': 'a.c',
        'b.o': 'b.asm',
        'c.o': 'c.cc',
    }
    objs = [
        'a.o',
        'c.o',
    ]
    expected = set(['a.c', 'c.cc'])
    self.assertEqual(expected, gg.GetSourceFileSet(objs_to_srcs, objs))

  def testGetSourceFileSet_NotFound(self):
    objs_to_srcs = {
        'a.o': 'a.c',
        'b.o': 'b.asm',
        'c.o': 'c.cc',
    }
    objs = [
        'd.o',
    ]
    self.assertRaises(KeyError, gg.GetSourceFileSet, objs_to_srcs, objs)


class SourceSetUnittest(unittest.TestCase):

  def testEquals(self):
    a = SourceSet(set(['a', 'b']), set([SourceListCondition('1', '2', '3')]))
    b = SourceSet(set(['a', 'b']), set([SourceListCondition('1', '2', '3')]))
    c = SourceSet(set(['c', 'd']), set([SourceListCondition('1', '2', '3')]))
    d = SourceSet(set(['a', 'b']), set([SourceListCondition('0', '2', '3')]))
    e = SourceSet(set(['a', 'b']), set([SourceListCondition('1', '0', '3')]))
    f = SourceSet(set(['a', 'b']), set([SourceListCondition('1', '2', '0')]))

    self.assertEqual(a, b)
    self.assertNotEqual(a, c)
    self.assertNotEqual(a, d)
    self.assertNotEqual(a, e)
    self.assertNotEqual(a, f)

  def testIntersect_Exact(self):
    a = SourceSet(set(['a', 'b']), set([SourceListCondition('1', '2', '3')]))
    b = SourceSet(set(['a', 'b']), set([SourceListCondition('3', '4', '6')]))

    c = a.Intersect(b)

    self.assertEqual(c.sources, set(['a', 'b']))
    self.assertEqual(
        c.conditions,
        set([
            SourceListCondition('1', '2', '3'),
            SourceListCondition('3', '4', '6')
        ]))
    self.assertFalse(c.IsEmpty())

  def testIntersect_Disjoint(self):
    a = SourceSet(set(['a', 'b']), set([SourceListCondition('1', '2', '3')]))
    b = SourceSet(set(['c', 'd']), set([SourceListCondition('3', '4', '6')]))

    c = a.Intersect(b)

    self.assertEqual(c.sources, set())
    self.assertEqual(
        c.conditions,
        set([
            SourceListCondition('1', '2', '3'),
            SourceListCondition('3', '4', '6')
        ]))
    self.assertTrue(c.IsEmpty())

  def testIntersect_Overlap(self):
    a = SourceSet(set(['a', 'b']), set([SourceListCondition('1', '2', '3')]))
    b = SourceSet(set(['b', 'c']), set([SourceListCondition('3', '4', '6')]))

    c = a.Intersect(b)

    self.assertEqual(c.sources, set(['b']))
    self.assertEqual(
        c.conditions,
        set([
            SourceListCondition('1', '2', '3'),
            SourceListCondition('3', '4', '6')
        ]))
    self.assertFalse(c.IsEmpty())

  def testDifference_Exact(self):
    a = SourceSet(set(['a', 'b']), set([SourceListCondition('1', '2', '3')]))
    b = SourceSet(set(['a', 'b']), set([SourceListCondition('1', '2', '3')]))

    c = a.Difference(b)

    self.assertEqual(c.sources, set())
    self.assertEqual(c.conditions, set([SourceListCondition('1', '2', '3')]))
    self.assertTrue(c.IsEmpty())

  def testDifference_Disjoint(self):
    a = SourceSet(set(['a', 'b']), set([SourceListCondition('1', '2', '3')]))
    b = SourceSet(set(['c', 'd']), set([SourceListCondition('3', '4', '6')]))

    c = a.Difference(b)

    self.assertEqual(c.sources, set(['a', 'b']))
    self.assertEqual(c.conditions, set())
    self.assertTrue(c.IsEmpty())

  def testDifference_Overlap(self):
    a = SourceSet(set(['a', 'b']), set([SourceListCondition('1', '2', '5')]))
    b = SourceSet(
        set(['b', 'c', 'd']),
        set([
            SourceListCondition('1', '2', '5'),
            SourceListCondition('3', '4', '6')
        ]))

    c = a.Difference(b)

    self.assertEqual(c.sources, set(['a']))
    self.assertEqual(c.conditions, set([SourceListCondition('1', '2', '5')]))
    self.assertFalse(c.IsEmpty())

  def testGenerateGnStanza(self):
    # ia32 should be x86.  Win should appear as an OS restriction.
    a = SourceSet(
        set(['a', 'b']), set([SourceListCondition('ia32', 'Chromium', 'win')]))
    a_stanza = a.GenerateGnStanza()
    string.index(a_stanza, 'current_cpu == "x86"')
    string.index(a_stanza, 'is_win')

    # x64 should just be x64.  Linux should appear as an OS restriction.
    b = SourceSet(
        set(['a', 'b']), set([SourceListCondition('x64', 'Chromium', 'linux')]))
    b_stanza = b.GenerateGnStanza()
    string.index(b_stanza, 'current_cpu == "x64"')
    string.index(b_stanza, 'use_linux_config')

    # arm should just be arm.
    c = SourceSet(
        set(['a', 'b']), set([SourceListCondition('arm', 'Chromium', 'linux')]))
    c_stanza = c.GenerateGnStanza()
    string.index(c_stanza, 'current_cpu == "arm"')

    # arm-neon should be arm and flip the arm_neon switch.
    d = SourceSet(
        set(['a', 'b']),
        set([SourceListCondition('arm-neon', 'Chromium', 'linux')]))
    d_stanza = d.GenerateGnStanza()
    string.index(d_stanza, 'current_cpu == "arm" && arm_use_neon')

    # Multiple conditions
    e = SourceSet(
        set(['a', 'b']),
        set([
            SourceListCondition('arm', 'Chrome', 'win'),
            SourceListCondition('x64', 'Chromium', 'linux')
        ]))
    e_stanza = e.GenerateGnStanza()
    string.index(e_stanza, ('is_win && current_cpu == "arm"'
                            ' && ffmpeg_branding == "Chrome"'))
    string.index(e_stanza, ('use_linux_config && current_cpu == "x64"'
                            ' && ffmpeg_branding == "Chromium"'))

  def testComplexSourceListConditions(self):
    # Create 2 sets with intersecting source 'a', but setup such that 'a'
    # is only valid for combinations (x86 && windows) || (x64 && linux). The
    # generated gn stanza should then not allow for inclusion of the 'a' file
    # for combinations like x86 && linux.
    a = SourceSet(set(['a']), set([SourceListCondition('x86', 'c', 'win')]))
    b = SourceSet(set(['a']), set([SourceListCondition('x64', 'c', 'linux')]))
    disjoint_sets = gg.CreatePairwiseDisjointSets([a, b])

    # This condition is bad because x86 && linux would pass. Admittedly a very
    # fragile way to test this, but evaulating gn stanzas is hard, and it at
    # least serves to document the motivation for the associated changes to
    # our generate_gn.py
    bad_condition = ('(current_cpu == "x86" || current_cpu == "x64")'
                     ' && (ffmpeg_branding == "c")'
                     ' && (is_win || is_linux || is_chromeos)')

    # Expect only a single set since the two original sets have the same source
    # list.
    self.assertEqual(1, len(disjoint_sets))

    stanza = disjoint_sets[0].GenerateGnStanza()
    self.assertEqual(string.find(stanza, bad_condition), -1)

  def assertEqualSourceSets(self, expected, actual):
    assert all(isinstance(a, SourceSet) for a in expected)
    assert all(isinstance(a, SourceSet) for a in actual)

    def SourceSetToString(source_set):
      sources = [str(e) for e in source_set.sources]
      conditions = [str(e) for e in source_set.conditions]
      sources_str = ','.join(sources)
      conditions_str = '\n\t'.join(conditions)
      return '  sources:%s\n  cs:\t%s' % (sources_str, conditions_str)

    missing_elements = expected.difference(actual)
    extra_elements = actual.difference(expected)
    msg = ''
    if len(missing_elements):
      msg += 'Missing expected elements:\n'
      for e in missing_elements:
        msg += SourceSetToString(e) + '\n'
    if len(extra_elements):
      msg += 'Found extra elements:\n'
      for e in extra_elements:
        msg += SourceSetToString(e) + '\n'

    self.assertTrue(expected == actual, msg=msg)

  def testCreatePairwiseDisjointSets_Pair(self):
    a = SourceSet(
        set(['common', 'intel']),
        set([SourceListCondition('ia32', 'Chromium', 'win')]))
    b = SourceSet(
        set(['common', 'intel', 'chrome']),
        set([SourceListCondition('ia32', 'Chrome', 'win')]))

    expected = set()
    expected.add(
        SourceSet(
            set(['common', 'intel']),
            set([
                SourceListCondition('ia32', 'Chromium', 'win'),
                SourceListCondition('ia32', 'Chrome', 'win')
            ])))
    expected.add(
        SourceSet(
            set(['chrome']), set([SourceListCondition('ia32', 'Chrome',
                                                      'win')])))

    source_sets = gg.CreatePairwiseDisjointSets([a, b])
    self.assertEqualSourceSets(expected, set(source_sets))

  def testCreatePairwiseDisjointSets_Triplet(self):
    a = SourceSet(
        set(['common', 'intel']),
        set([SourceListCondition('ia32', 'Chromium', 'win')]))
    b = SourceSet(
        set(['common', 'intel', 'chrome']),
        set([SourceListCondition('x64', 'Chrome', 'win')]))
    c = SourceSet(
        set(['common', 'arm']),
        set([SourceListCondition('arm', 'Chromium', 'win')]))

    expected = set()
    expected.add(
        SourceSet(
            set(['common']),
            set([
                SourceListCondition('ia32', 'Chromium', 'win'),
                SourceListCondition('x64', 'Chrome', 'win'),
                SourceListCondition('arm', 'Chromium', 'win')
            ])))
    expected.add(
        SourceSet(
            set(['intel']),
            set([
                SourceListCondition('ia32', 'Chromium', 'win'),
                SourceListCondition('x64', 'Chrome', 'win')
            ])))
    expected.add(
        SourceSet(
            set(['chrome']), set([SourceListCondition('x64', 'Chrome',
                                                      'win')])))
    expected.add(
        SourceSet(
            set(['arm']), set([SourceListCondition('arm', 'Chromium', 'win')])))

    source_sets = gg.CreatePairwiseDisjointSets([a, b, c])
    self.assertEqualSourceSets(expected, set(source_sets))

  def testCreatePairwiseDisjointSets_Multiple(self):
    a = SourceSet(
        set(['common', 'intel']),
        set([SourceListCondition('ia32', 'Chromium', 'linux')]))
    b = SourceSet(
        set(['common', 'intel', 'chrome']),
        set([SourceListCondition('ia32', 'Chrome', 'linux')]))
    c = SourceSet(
        set(['common', 'intel']),
        set([SourceListCondition('x64', 'Chromium', 'linux')]))
    d = SourceSet(
        set(['common', 'intel', 'chrome']),
        set([SourceListCondition('x64', 'Chrome', 'linux')]))
    e = SourceSet(
        set(['common', 'arm']),
        set([SourceListCondition('arm', 'Chromium', 'linux')]))
    f = SourceSet(
        set(['common', 'arm-neon', 'chrome', 'chromeos']),
        set([SourceListCondition('arm-neon', 'ChromeOS', 'linux')]))

    expected = set()
    expected.add(
        SourceSet(
            set(['common']),
            set([
                SourceListCondition('ia32', 'Chromium', 'linux'),
                SourceListCondition('ia32', 'Chrome', 'linux'),
                SourceListCondition('x64', 'Chromium', 'linux'),
                SourceListCondition('x64', 'Chrome', 'linux'),
                SourceListCondition('arm', 'Chromium', 'linux'),
                SourceListCondition('arm-neon', 'ChromeOS', 'linux')
            ])))
    expected.add(
        SourceSet(
            set(['intel']),
            set([
                SourceListCondition('ia32', 'Chromium', 'linux'),
                SourceListCondition('ia32', 'Chrome', 'linux'),
                SourceListCondition('x64', 'Chromium', 'linux'),
                SourceListCondition('x64', 'Chrome', 'linux')
            ])))
    expected.add(
        SourceSet(
            set(['arm']), set([SourceListCondition('arm', 'Chromium',
                                                   'linux')])))
    expected.add(
        SourceSet(
            set(['chrome']),
            set([
                SourceListCondition('ia32', 'Chrome', 'linux'),
                SourceListCondition('x64', 'Chrome', 'linux'),
                SourceListCondition('arm-neon', 'ChromeOS', 'linux')
            ])))
    expected.add(
        SourceSet(
            set(['arm-neon', 'chromeos']),
            set([SourceListCondition('arm-neon', 'ChromeOS', 'linux')])))

    source_sets = gg.CreatePairwiseDisjointSets([a, b, c, d, e, f])
    self.assertEqualSourceSets(expected, set(source_sets))

  def testReduceConditions(self):
    # Set conditions span all of the supported architectures for linux.
    a = SourceSet(
        set(['foo.c']),
        set([
            SourceListCondition('ia32', 'Chromium', 'linux'),
            SourceListCondition('x64', 'Chromium', 'linux'),
            SourceListCondition('arm', 'Chromium', 'linux'),
            SourceListCondition('arm64', 'Chromium', 'linux'),
            SourceListCondition('arm-neon', 'Chromium', 'linux'),
            SourceListCondition('mipsel', 'Chromium', 'linux'),
            SourceListCondition('mips64el', 'Chromium', 'linux'),
        ]))
    gg.ReduceConditionalLogic(a)

    # Conditions should reduce to a single condition with wild-card for arch.
    expected = set([SourceListCondition('*', 'Chromium', 'linux')])
    self.assertEqual(expected, a.conditions)

    # Set conditions span all of the supported architectures for windows.
    b = SourceSet(
        set(['foo.c']),
        set([
            SourceListCondition('ia32', 'Chromium', 'win'),
            SourceListCondition('x64', 'Chromium', 'win'),
            SourceListCondition('arm64', 'Chromium', 'win'),
        ]))
    gg.ReduceConditionalLogic(b)

    # Conditions should reduce to a single condition with wild-card for
    expected = set([SourceListCondition('*', 'Chromium', 'win')])
    self.assertEqual(expected, b.conditions)

    # Set conditions span all supported architectures and brandings for windows.
    b = SourceSet(
        set(['foo.c']),
        set([
            SourceListCondition('ia32', 'Chromium', 'win'),
            SourceListCondition('x64', 'Chromium', 'win'),
            SourceListCondition('arm64', 'Chromium', 'win'),
            SourceListCondition('ia32', 'Chrome', 'win'),
            SourceListCondition('x64', 'Chrome', 'win'),
            SourceListCondition('arm64', 'Chrome', 'win'),
        ]))
    gg.ReduceConditionalLogic(b)
    expected = set([SourceListCondition('*', '*', 'win')])
    self.assertEqual(expected, b.conditions)

    # Set conditions span all supported platforms.
    c = SourceSet(
        set(['foo.c']),
        set([
            SourceListCondition('x64', 'Chromium', 'win'),
            SourceListCondition('x64', 'Chromium', 'mac'),
            SourceListCondition('x64', 'Chromium', 'linux'),
            SourceListCondition('x64', 'Chromium', 'android'),
        ]))
    gg.ReduceConditionalLogic(c)
    expected = set([SourceListCondition('x64', 'Chromium', '*')])
    self.assertEqual(expected, c.conditions)

    # Spans all architectures for Chromium, but also all targets for ia32 & win.
    d = SourceSet(
        set(['foo.c']),
        set([
            SourceListCondition('arm64', 'Chromium', 'win'),
            SourceListCondition('x64', 'Chromium', 'win'),
            SourceListCondition('ia32', 'Chromium', 'win'),
            SourceListCondition('ia32', 'Chrome', 'win'),
        ]))
    gg.ReduceConditionalLogic(d)
    expected = set([
        SourceListCondition('*', 'Chromium', 'win'),
        SourceListCondition('ia32', '*', 'win'),
    ])
    self.assertEqual(expected, d.conditions)

  def testReduceConditions_fullSpan(self):
    # Build SourceSet with conditions spanning every combination of attributes.
    ss = SourceSet(set(['foo.c']), set())
    for arch in gg.SUPPORT_MATRIX[gg.Attr.ARCHITECTURE]:
      for target in gg.SUPPORT_MATRIX[gg.Attr.TARGET]:
        for platform in gg.SUPPORT_MATRIX[gg.Attr.PLATFORM]:
          ss.conditions.add(SourceListCondition(arch, target, platform))

    gg.ReduceConditionalLogic(ss)
    expected = set([SourceListCondition('*', '*', '*')])
    self.assertEqual(expected, ss.conditions)

  def testGenerateStanzaWildCard(self):
    a = SourceSet(
        set(['foo.c']), set([SourceListCondition('x64', 'Chromium', '*')]))
    stanza = a.GenerateGnStanza()
    string.index(stanza, '== "x64"')
    string.index(stanza, 'ffmpeg_branding == "Chromium"')
    # OS is wild-card, so it should not be mentioned in the stanza.
    self.assertEqual(-1, string.find(stanza, 'OS =='))

  def testFixObjectBasenameCollisions(self):
    # Use callback to capture executed renames.
    observed_renames = set()

    def do_rename_cb(old_path, new_path, content):
      observed_renames.add((old_path, new_path))

    # Verify basic rename case - same basename in different directories.
    a = SourceSet(set(['foo.c']), set([SourceListCondition('*', '*', '*')]))
    b = SourceSet(
        set([path.join('a','foo.c'), path.join('b', 'foo.c')]),
        set([SourceListCondition('*', '*', '*')]))
    expected_renames = set([(path.join('a', 'foo.c'),
                             path.join('a', 'autorename_a_foo.c')),
                            (path.join('b', 'foo.c'),
                             path.join('b', 'autorename_b_foo.c'))])
    gg.FixObjectBasenameCollisions([a, b], [], do_rename_cb, log_renames=False)
    self.assertEqual(expected_renames, observed_renames)

    # Verify renames file extensions in same and different directory.
    observed_renames = set()
    a = SourceSet(set(['foo.c']), set([SourceListCondition('*', '*', '*')]))
    b = SourceSet(set(['foo.asm']), set([SourceListCondition('*', '*', '*')]))
    c = SourceSet(set([path.join('a', 'foo.S'), path.join('b', 'foo.asm')]),
                  set([SourceListCondition('*', '*', '*')]))
    expected_renames = set([('foo.asm', 'autorename_foo.asm'),
                            (path.join('a', 'foo.S'),
                             path.join('a', 'autorename_a_foo.S')),
                            (path.join('b', 'foo.asm'),
                             path.join('b', 'autorename_b_foo.asm'))])
    gg.FixObjectBasenameCollisions(
        [a, b, c], [], do_rename_cb, log_renames=False)
    self.assertEqual(expected_renames, observed_renames)


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