Add m-esr52 at 52.6.0

1 files changed, 431 insertions, 0 deletions

diff --git a/config/tests/unit-expandlibs.py b/config/tests/unit-expandlibs.py
new file mode 100644
index 000000000..3c7e5a44d
--- /dev/null
+++ b/config/tests/unit-expandlibs.py
@@ -0,0 +1,431 @@
+import subprocess
+import unittest
+import sys
+import os
+import imp
+from tempfile import mkdtemp
+from shutil import rmtree
+import mozunit
+
+from UserString import UserString
+# Create a controlled configuration for use by expandlibs
+config_win = {
+    'AR': 'lib',
+    'AR_EXTRACT': '',
+    'DLL_PREFIX': '',
+    'LIB_PREFIX': '',
+    'OBJ_SUFFIX': '.obj',
+    'LIB_SUFFIX': '.lib',
+    'DLL_SUFFIX': '.dll',
+    'IMPORT_LIB_SUFFIX': '.lib',
+    'LIBS_DESC_SUFFIX': '.desc',
+    'EXPAND_LIBS_LIST_STYLE': 'list',
+}
+config_unix = {
+    'AR': 'ar',
+    'AR_EXTRACT': 'ar -x',
+    'DLL_PREFIX': 'lib',
+    'LIB_PREFIX': 'lib',
+    'OBJ_SUFFIX': '.o',
+    'LIB_SUFFIX': '.a',
+    'DLL_SUFFIX': '.so',
+    'IMPORT_LIB_SUFFIX': '',
+    'LIBS_DESC_SUFFIX': '.desc',
+    'EXPAND_LIBS_LIST_STYLE': 'linkerscript',
+}
+
+config = sys.modules['expandlibs_config'] = imp.new_module('expandlibs_config')
+
+from expandlibs import LibDescriptor, ExpandArgs, relativize
+from expandlibs_gen import generate
+from expandlibs_exec import ExpandArgsMore, SectionFinder
+
+def Lib(name):
+    return config.LIB_PREFIX + name + config.LIB_SUFFIX
+
+def Obj(name):
+    return name + config.OBJ_SUFFIX
+
+def Dll(name):
+    return config.DLL_PREFIX + name + config.DLL_SUFFIX
+
+def ImportLib(name):
+    if not len(config.IMPORT_LIB_SUFFIX): return Dll(name)
+    return config.LIB_PREFIX + name + config.IMPORT_LIB_SUFFIX
+
+class TestRelativize(unittest.TestCase):
+    def test_relativize(self):
+        '''Test relativize()'''
+        os_path_exists = os.path.exists
+        def exists(path):
+            return True
+        os.path.exists = exists
+        self.assertEqual(relativize(os.path.abspath(os.curdir)), os.curdir)
+        self.assertEqual(relativize(os.path.abspath(os.pardir)), os.pardir)
+        self.assertEqual(relativize(os.path.join(os.curdir, 'a')), 'a')
+        self.assertEqual(relativize(os.path.join(os.path.abspath(os.curdir), 'a')), 'a')
+        # relativize is expected to return the absolute path if it is shorter
+        self.assertEqual(relativize(os.sep), os.sep)
+        os.path.exists = os.path.exists
+
+class TestLibDescriptor(unittest.TestCase):
+    def test_serialize(self):
+        '''Test LibDescriptor's serialization'''
+        desc = LibDescriptor()
+        desc[LibDescriptor.KEYS[0]] = ['a', 'b']
+        self.assertEqual(str(desc), "{0} = a b".format(LibDescriptor.KEYS[0]))
+        desc['unsupported-key'] = ['a']
+        self.assertEqual(str(desc), "{0} = a b".format(LibDescriptor.KEYS[0]))
+        desc[LibDescriptor.KEYS[1]] = ['c', 'd', 'e']
+        self.assertEqual(str(desc),
+                         "{0} = a b\n{1} = c d e"
+                         .format(LibDescriptor.KEYS[0], LibDescriptor.KEYS[1]))
+        desc[LibDescriptor.KEYS[0]] = []
+        self.assertEqual(str(desc), "{0} = c d e".format(LibDescriptor.KEYS[1]))
+
+    def test_read(self):
+        '''Test LibDescriptor's initialization'''
+        desc_list = ["# Comment",
+                     "{0} = a b".format(LibDescriptor.KEYS[1]),
+                     "", # Empty line
+                     "foo = bar", # Should be discarded
+                     "{0} = c d e".format(LibDescriptor.KEYS[0])]
+        desc = LibDescriptor(desc_list)
+        self.assertEqual(desc[LibDescriptor.KEYS[1]], ['a', 'b'])
+        self.assertEqual(desc[LibDescriptor.KEYS[0]], ['c', 'd', 'e'])
+        self.assertEqual(False, 'foo' in desc)
+
+def wrap_method(conf, wrapped_method):
+    '''Wrapper used to call a test with a specific configuration'''
+    def _method(self):
+        for key in conf:
+            setattr(config, key, conf[key])
+        self.init()
+        try:
+            wrapped_method(self)
+        except:
+            raise
+        finally:
+            self.cleanup()
+    return _method
+
+class ReplicateTests(type):
+    '''Replicates tests for unix and windows variants'''
+    def __new__(cls, clsName, bases, dict):
+        for name in [key for key in dict if key.startswith('test_')]:
+            dict[name + '_unix'] = wrap_method(config_unix, dict[name])
+            dict[name + '_unix'].__doc__ = dict[name].__doc__ + ' (unix)'
+            dict[name + '_win'] = wrap_method(config_win, dict[name])
+            dict[name + '_win'].__doc__ = dict[name].__doc__ + ' (win)'
+            del dict[name]
+        return type.__new__(cls, clsName, bases, dict)
+
+class TestCaseWithTmpDir(unittest.TestCase):
+    __metaclass__ = ReplicateTests
+    def init(self):
+        self.tmpdir = os.path.abspath(mkdtemp(dir=os.curdir))
+
+    def cleanup(self):
+        rmtree(self.tmpdir)
+
+    def touch(self, files):
+        for f in files:
+            open(f, 'w').close()
+
+    def tmpfile(self, *args):
+        return os.path.join(self.tmpdir, *args)
+
+class TestExpandLibsGen(TestCaseWithTmpDir):
+    def test_generate(self):
+        '''Test library descriptor generation'''
+        files = [self.tmpfile(f) for f in
+                 [Lib('a'), Obj('b'), Lib('c'), Obj('d'), Obj('e'), Lib('f')]]
+        self.touch(files[:-1])
+        self.touch([files[-1] + config.LIBS_DESC_SUFFIX])
+
+        desc = generate(files)
+        self.assertEqual(desc['OBJS'], [self.tmpfile(Obj(s)) for s in ['b', 'd', 'e']])
+        self.assertEqual(desc['LIBS'], [self.tmpfile(Lib(s)) for s in ['a', 'c', 'f']])
+
+        self.assertRaises(Exception, generate, files + [self.tmpfile(Obj('z'))])
+        self.assertRaises(Exception, generate, files + [self.tmpfile(Lib('y'))])
+
+class TestExpandInit(TestCaseWithTmpDir):
+    def init(self):
+        ''' Initializes test environment for library expansion tests'''
+        super(TestExpandInit, self).init()
+        # Create 2 fake libraries, each containing 3 objects, and the second
+        # including the first one and another library.
+        os.mkdir(self.tmpfile('libx'))
+        os.mkdir(self.tmpfile('liby'))
+        self.libx_files = [self.tmpfile('libx', Obj(f)) for f in ['g', 'h', 'i']]
+        self.liby_files = [self.tmpfile('liby', Obj(f)) for f in ['j', 'k', 'l']] + [self.tmpfile('liby', Lib('z'))]
+        self.touch(self.libx_files + self.liby_files)
+        with open(self.tmpfile('libx', Lib('x') + config.LIBS_DESC_SUFFIX), 'w') as f:
+            f.write(str(generate(self.libx_files)))
+        with open(self.tmpfile('liby', Lib('y') + config.LIBS_DESC_SUFFIX), 'w') as f:
+            f.write(str(generate(self.liby_files + [self.tmpfile('libx', Lib('x'))])))
+
+        # Create various objects and libraries 
+        self.arg_files = [self.tmpfile(f) for f in [Lib('a'), Obj('b'), Obj('c'), Lib('d'), Obj('e')]]
+        # We always give library names (LIB_PREFIX/SUFFIX), even for
+        # dynamic/import libraries
+        self.files = self.arg_files + [self.tmpfile(ImportLib('f'))]
+        self.arg_files += [self.tmpfile(Lib('f'))]
+        self.touch(self.files)
+
+    def assertRelEqual(self, args1, args2):
+        self.assertEqual(args1, [relativize(a) for a in args2])
+
+class TestExpandArgs(TestExpandInit):
+    def test_expand(self):
+        '''Test library expansion'''
+        # Expanding arguments means libraries with a descriptor are expanded
+        # with the descriptor content, and import libraries are used when
+        # a library doesn't exist
+        args = ExpandArgs(['foo', '-bar'] + self.arg_files + [self.tmpfile('liby', Lib('y'))])
+        self.assertRelEqual(args, ['foo', '-bar'] + self.files + self.liby_files + self.libx_files) 
+
+        # When a library exists at the same time as a descriptor, we still use
+        # the descriptor.
+        self.touch([self.tmpfile('libx', Lib('x'))])
+        args = ExpandArgs(['foo', '-bar'] + self.arg_files + [self.tmpfile('liby', Lib('y'))])
+        self.assertRelEqual(args, ['foo', '-bar'] + self.files + self.liby_files + self.libx_files)
+
+        self.touch([self.tmpfile('liby', Lib('y'))])
+        args = ExpandArgs(['foo', '-bar'] + self.arg_files + [self.tmpfile('liby', Lib('y'))])
+        self.assertRelEqual(args, ['foo', '-bar'] + self.files + self.liby_files + self.libx_files)
+
+class TestExpandArgsMore(TestExpandInit):
+    def test_makelist(self):
+        '''Test grouping object files in lists'''
+        # ExpandArgsMore does the same as ExpandArgs
+        with ExpandArgsMore(['foo', '-bar'] + self.arg_files + [self.tmpfile('liby', Lib('y'))]) as args:
+            self.assertRelEqual(args, ['foo', '-bar'] + self.files + self.liby_files + self.libx_files) 
+
+            # But also has an extra method replacing object files with a list
+            args.makelist()
+            # self.files has objects at #1, #2, #4
+            self.assertRelEqual(args[:3], ['foo', '-bar'] + self.files[:1])
+            self.assertRelEqual(args[4:], [self.files[3]] + self.files[5:] + [self.tmpfile('liby', Lib('z'))])
+
+            # Check the list file content
+            objs = [f for f in self.files + self.liby_files + self.libx_files if f.endswith(config.OBJ_SUFFIX)]
+            if config.EXPAND_LIBS_LIST_STYLE == "linkerscript":
+                self.assertNotEqual(args[3][0], '@')
+                filename = args[3]
+                content = ['INPUT("{0}")'.format(relativize(f)) for f in objs]
+                with open(filename, 'r') as f:
+                    self.assertEqual([l.strip() for l in f.readlines() if len(l.strip())], content)
+            elif config.EXPAND_LIBS_LIST_STYLE == "list":
+                self.assertEqual(args[3][0], '@')
+                filename = args[3][1:]
+                content = objs
+                with open(filename, 'r') as f:
+                    self.assertRelEqual([l.strip() for l in f.readlines() if len(l.strip())], content)
+
+            tmp = args.tmp
+        # Check that all temporary files are properly removed
+        self.assertEqual(True, all([not os.path.exists(f) for f in tmp]))
+
+    def test_extract(self):
+        '''Test library extraction'''
+        # Divert subprocess.call
+        subprocess_call = subprocess.call
+        subprocess_check_output = subprocess.check_output
+        def call(args, **kargs):
+            if config.AR == 'lib':
+                self.assertEqual(args[:2], [config.AR, '-NOLOGO'])
+                self.assertTrue(args[2].startswith('-EXTRACT:'))
+                extract = [args[2][len('-EXTRACT:'):]]
+                self.assertTrue(extract)
+                args = args[3:]
+            else:
+                # The command called is always AR_EXTRACT
+                ar_extract = config.AR_EXTRACT.split()
+                self.assertEqual(args[:len(ar_extract)], ar_extract)
+                args = args[len(ar_extract):]
+            # Remaining argument is always one library
+            self.assertEqual(len(args), 1)
+            arg = args[0]
+            self.assertEqual(os.path.splitext(arg)[1], config.LIB_SUFFIX)
+            # Simulate file extraction
+            lib = os.path.splitext(os.path.basename(arg))[0]
+            if config.AR != 'lib':
+                extract = [lib, lib + '2']
+            extract = [os.path.join(kargs['cwd'], f) for f in extract]
+            if config.AR != 'lib':
+                extract = [Obj(f) for f in extract]
+            if not lib in extracted:
+                extracted[lib] = []
+            extracted[lib].extend(extract)
+            self.touch(extract)
+        subprocess.call = call
+
+        def check_output(args, **kargs):
+            # The command called is always AR
+            ar = config.AR
+            self.assertEqual(args[0:3], [ar, '-NOLOGO', '-LIST'])
+            # Remaining argument is always one library
+            self.assertRelEqual([os.path.splitext(arg)[1] for arg in args[3:]],
+[config.LIB_SUFFIX])
+            # Simulate LIB -NOLOGO -LIST
+            lib = os.path.splitext(os.path.basename(args[3]))[0]
+            return '%s\n%s\n' % (Obj(lib), Obj(lib + '2'))
+        subprocess.check_output = check_output
+
+        # ExpandArgsMore does the same as ExpandArgs
+        self.touch([self.tmpfile('liby', Lib('y'))])
+        for iteration in (1, 2):
+            with ExpandArgsMore(['foo', '-bar'] + self.arg_files + [self.tmpfile('liby', Lib('y'))]) as args:
+                files = self.files + self.liby_files + self.libx_files
+
+                self.assertRelEqual(args, ['foo', '-bar'] + files)
+
+                extracted = {}
+                # ExpandArgsMore also has an extra method extracting static libraries
+                # when possible
+                args.extract()
+
+                # With AR_EXTRACT, it uses the descriptors when there are, and
+                # actually
+                # extracts the remaining libraries
+                extracted_args = []
+                for f in files:
+                    if f.endswith(config.LIB_SUFFIX):
+                        base = os.path.splitext(os.path.basename(f))[0]
+                        # On the first iteration, we test the behavior of
+                        # extracting archives that don't have a copy of their
+                        # contents next to them, which is to use the file
+                        # extracted from the archive in a temporary directory.
+                        # On the second iteration, we test extracting archives
+                        # that do have a copy of their contents next to them,
+                        # in which case those contents are used instead of the
+                        # temporarily extracted files.
+                        if iteration == 1:
+                            extracted_args.extend(sorted(extracted[base]))
+                        else:
+                            dirname = os.path.dirname(f[len(self.tmpdir)+1:])
+                            if base.endswith('f'):
+                                dirname = os.path.join(dirname, 'foo', 'bar')
+                            extracted_args.extend([self.tmpfile(dirname, Obj(base)), self.tmpfile(dirname, Obj(base + '2'))])
+                    else:
+                        extracted_args.append(f)
+                self.assertRelEqual(args, ['foo', '-bar'] + extracted_args)
+
+                tmp = args.tmp
+            # Check that all temporary files are properly removed
+            self.assertEqual(True, all([not os.path.exists(f) for f in tmp]))
+
+            # Create archives contents next to them for the second iteration.
+            base = os.path.splitext(Lib('_'))[0]
+            self.touch(self.tmpfile(Obj(base.replace('_', suffix))) for suffix in ('a', 'a2', 'd', 'd2'))
+            try:
+                os.makedirs(self.tmpfile('foo', 'bar'))
+            except:
+                pass
+            self.touch(self.tmpfile('foo', 'bar', Obj(base.replace('_', suffix))) for suffix in ('f', 'f2'))
+            self.touch(self.tmpfile('liby', Obj(base.replace('_', suffix))) for suffix in ('z', 'z2'))
+
+        # Restore subprocess.call and subprocess.check_output
+        subprocess.call = subprocess_call
+        subprocess.check_output = subprocess_check_output
+
+class FakeProcess(object):
+    def __init__(self, out, err = ''):
+        self.out = out
+        self.err = err
+
+    def communicate(self):
+        return (self.out, self.err)
+
+OBJDUMPS = {
+'foo.o': '''
+00000000 g     F .text\t00000001 foo
+00000000 g     F .text._Z6foobarv\t00000001 _Z6foobarv
+00000000 g     F .text.hello\t00000001 hello
+00000000 g     F .text._ZThn4_6foobarv\t00000001 _ZThn4_6foobarv
+''',
+'bar.o': '''
+00000000 g     F .text.hi\t00000001 hi
+00000000 g     F .text.hot._Z6barbazv\t00000001 .hidden _Z6barbazv
+''',
+}
+
+PRINT_ICF = '''
+ld: ICF folding section '.text.hello' in file 'foo.o'into '.text.hi' in file 'bar.o'
+ld: ICF folding section '.foo' in file 'foo.o'into '.foo' in file 'bar.o'
+'''
+
+class SubprocessPopen(object):
+    def __init__(self, test):
+        self.test = test
+
+    def __call__(self, args, stdout = None, stderr = None):
+        self.test.assertEqual(stdout, subprocess.PIPE)
+        self.test.assertEqual(stderr, subprocess.PIPE)
+        if args[0] == 'objdump':
+            self.test.assertEqual(args[1], '-t')
+            self.test.assertTrue(args[2] in OBJDUMPS)
+            return FakeProcess(OBJDUMPS[args[2]])
+        else:
+            return FakeProcess('', PRINT_ICF)
+
+class TestSectionFinder(unittest.TestCase):
+    def test_getSections(self):
+        '''Test SectionFinder'''
+        # Divert subprocess.Popen
+        subprocess_popen = subprocess.Popen
+        subprocess.Popen = SubprocessPopen(self)
+        config.EXPAND_LIBS_ORDER_STYLE = 'linkerscript'
+        config.OBJ_SUFFIX = '.o'
+        config.LIB_SUFFIX = '.a'
+        finder = SectionFinder(['foo.o', 'bar.o'])
+        self.assertEqual(finder.getSections('foobar'), [])
+        self.assertEqual(finder.getSections('_Z6barbazv'), ['.text.hot._Z6barbazv'])
+        self.assertEqual(finder.getSections('_Z6foobarv'), ['.text._Z6foobarv', '.text._ZThn4_6foobarv'])
+        self.assertEqual(finder.getSections('_ZThn4_6foobarv'), ['.text._Z6foobarv', '.text._ZThn4_6foobarv'])
+        subprocess.Popen = subprocess_popen
+
+class TestSymbolOrder(unittest.TestCase):
+    def test_getOrderedSections(self):
+        '''Test ExpandMoreArgs' _getOrderedSections'''
+        # Divert subprocess.Popen
+        subprocess_popen = subprocess.Popen
+        subprocess.Popen = SubprocessPopen(self)
+        config.EXPAND_LIBS_ORDER_STYLE = 'linkerscript'
+        config.OBJ_SUFFIX = '.o'
+        config.LIB_SUFFIX = '.a'
+        config.LD_PRINT_ICF_SECTIONS = ''
+        args = ExpandArgsMore(['foo', '-bar', 'bar.o', 'foo.o'])
+        self.assertEqual(args._getOrderedSections(['_Z6foobarv', '_Z6barbazv']), ['.text._Z6foobarv', '.text._ZThn4_6foobarv', '.text.hot._Z6barbazv'])
+        self.assertEqual(args._getOrderedSections(['_ZThn4_6foobarv', '_Z6barbazv']), ['.text._Z6foobarv', '.text._ZThn4_6foobarv', '.text.hot._Z6barbazv'])
+        subprocess.Popen = subprocess_popen
+
+    def test_getFoldedSections(self):
+        '''Test ExpandMoreArgs' _getFoldedSections'''
+        # Divert subprocess.Popen
+        subprocess_popen = subprocess.Popen
+        subprocess.Popen = SubprocessPopen(self)
+        config.LD_PRINT_ICF_SECTIONS = '-Wl,--print-icf-sections'
+        args = ExpandArgsMore(['foo', '-bar', 'bar.o', 'foo.o'])
+        self.assertEqual(args._getFoldedSections(), {'.text.hello': ['.text.hi'], '.text.hi': ['.text.hello']})
+        subprocess.Popen = subprocess_popen
+
+    def test_getOrderedSectionsWithICF(self):
+        '''Test ExpandMoreArgs' _getOrderedSections, with ICF'''
+        # Divert subprocess.Popen
+        subprocess_popen = subprocess.Popen
+        subprocess.Popen = SubprocessPopen(self)
+        config.EXPAND_LIBS_ORDER_STYLE = 'linkerscript'
+        config.OBJ_SUFFIX = '.o'
+        config.LIB_SUFFIX = '.a'
+        config.LD_PRINT_ICF_SECTIONS = '-Wl,--print-icf-sections'
+        args = ExpandArgsMore(['foo', '-bar', 'bar.o', 'foo.o'])
+        self.assertEqual(args._getOrderedSections(['hello', '_Z6barbazv']), ['.text.hello', '.text.hi', '.text.hot._Z6barbazv'])
+        self.assertEqual(args._getOrderedSections(['_ZThn4_6foobarv', 'hi', '_Z6barbazv']), ['.text._Z6foobarv', '.text._ZThn4_6foobarv', '.text.hi', '.text.hello', '.text.hot._Z6barbazv'])
+        subprocess.Popen = subprocess_popen
+
+
+if __name__ == '__main__':
+    mozunit.main()