| #!/usr/bin/env python3 |
| # Copyright 2016 The Chromium Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import os |
| import pathlib |
| import shutil |
| import sys |
| import tempfile |
| import textwrap |
| import unittest |
| from unittest import mock |
| |
| import gn_helpers |
| |
| |
| class UnitTest(unittest.TestCase): |
| def test_ToGNString(self): |
| test_cases = [ |
| (42, '42', '42'), ('foo', '"foo"', '"foo"'), (True, 'true', 'true'), |
| (False, 'false', 'false'), ('', '""', '""'), |
| ('\\$"$\\', '"\\\\\\$\\"\\$\\\\"', '"\\\\\\$\\"\\$\\\\"'), |
| (' \t\r\n', '" $0x09$0x0D$0x0A"', '" $0x09$0x0D$0x0A"'), |
| (u'\u2713', '"$0xE2$0x9C$0x93"', '"$0xE2$0x9C$0x93"'), |
| ([], '[ ]', '[]'), ([1], '[ 1 ]', '[\n 1\n]\n'), |
| ([3, 1, 4, 1], '[ 3, 1, 4, 1 ]', '[\n 3,\n 1,\n 4,\n 1\n]\n'), |
| (['a', True, 2], '[ "a", true, 2 ]', '[\n "a",\n true,\n 2\n]\n'), |
| ({ |
| 'single': 'item' |
| }, 'single = "item"\n', 'single = "item"\n'), |
| ({ |
| 'kEy': 137, |
| '_42A_Zaz_': [False, True] |
| }, '_42A_Zaz_ = [ false, true ]\nkEy = 137\n', |
| '_42A_Zaz_ = [\n false,\n true\n]\nkEy = 137\n'), |
| ([1, 'two', |
| ['"thr,.$\\', True, False, [], |
| u'(\u2713)']], '[ 1, "two", [ "\\"thr,.\\$\\\\", true, false, ' + |
| '[ ], "($0xE2$0x9C$0x93)" ] ]', '''[ |
| 1, |
| "two", |
| [ |
| "\\"thr,.\\$\\\\", |
| true, |
| false, |
| [], |
| "($0xE2$0x9C$0x93)" |
| ] |
| ] |
| '''), |
| ({ |
| 's': 'foo', |
| 'n': 42, |
| 'b': True, |
| 'a': [3, 'x'] |
| }, 'a = [ 3, "x" ]\nb = true\nn = 42\ns = "foo"\n', |
| 'a = [\n 3,\n "x"\n]\nb = true\nn = 42\ns = "foo"\n'), |
| ( |
| [[[], [[]]], []], |
| '[ [ [ ], [ [ ] ] ], [ ] ]', |
| '[\n [\n [],\n [\n []\n ]\n ],\n []\n]\n', |
| ), |
| ( |
| [{ |
| 'a': 1, |
| 'c': { |
| 'z': 8 |
| }, |
| 'b': [] |
| }], |
| '[ { a = 1\nb = [ ]\nc = { z = 8 } } ]\n', |
| '[\n {\n a = 1\n b = []\n c = {\n' + |
| ' z = 8\n }\n }\n]\n', |
| ) |
| ] |
| for obj, exp_ugly, exp_pretty in test_cases: |
| out_ugly = gn_helpers.ToGNString(obj) |
| self.assertEqual(exp_ugly, out_ugly) |
| out_pretty = gn_helpers.ToGNString(obj, pretty=True) |
| self.assertEqual(exp_pretty, out_pretty) |
| |
| def test_UnescapeGNString(self): |
| # Backslash followed by a \, $, or " means the folling character without |
| # the special meaning. Backslash followed by everything else is a literal. |
| self.assertEqual( |
| gn_helpers.UnescapeGNString('\\as\\$\\\\asd\\"'), |
| '\\as$\\asd"') |
| |
| def test_FromGNString(self): |
| self.assertEqual( |
| gn_helpers.FromGNString('[1, -20, true, false,["as\\"", []]]'), |
| [ 1, -20, True, False, [ 'as"', [] ] ]) |
| |
| with self.assertRaises(gn_helpers.GNError): |
| parser = gn_helpers.GNValueParser('123 456') |
| parser.Parse() |
| |
| def test_ParseBool(self): |
| parser = gn_helpers.GNValueParser('true') |
| self.assertEqual(parser.Parse(), True) |
| |
| parser = gn_helpers.GNValueParser('false') |
| self.assertEqual(parser.Parse(), False) |
| |
| def test_ParseNumber(self): |
| parser = gn_helpers.GNValueParser('123') |
| self.assertEqual(parser.ParseNumber(), 123) |
| |
| with self.assertRaises(gn_helpers.GNError): |
| parser = gn_helpers.GNValueParser('') |
| parser.ParseNumber() |
| with self.assertRaises(gn_helpers.GNError): |
| parser = gn_helpers.GNValueParser('a123') |
| parser.ParseNumber() |
| |
| def test_ParseString(self): |
| parser = gn_helpers.GNValueParser('"asdf"') |
| self.assertEqual(parser.ParseString(), 'asdf') |
| |
| with self.assertRaises(gn_helpers.GNError): |
| parser = gn_helpers.GNValueParser('') # Empty. |
| parser.ParseString() |
| with self.assertRaises(gn_helpers.GNError): |
| parser = gn_helpers.GNValueParser('asdf') # Unquoted. |
| parser.ParseString() |
| with self.assertRaises(gn_helpers.GNError): |
| parser = gn_helpers.GNValueParser('"trailing') # Unterminated. |
| parser.ParseString() |
| |
| def test_ParseList(self): |
| parser = gn_helpers.GNValueParser('[1,]') # Optional end comma OK. |
| self.assertEqual(parser.ParseList(), [ 1 ]) |
| |
| with self.assertRaises(gn_helpers.GNError): |
| parser = gn_helpers.GNValueParser('') # Empty. |
| parser.ParseList() |
| with self.assertRaises(gn_helpers.GNError): |
| parser = gn_helpers.GNValueParser('asdf') # No []. |
| parser.ParseList() |
| with self.assertRaises(gn_helpers.GNError): |
| parser = gn_helpers.GNValueParser('[1, 2') # Unterminated |
| parser.ParseList() |
| with self.assertRaises(gn_helpers.GNError): |
| parser = gn_helpers.GNValueParser('[1 2]') # No separating comma. |
| parser.ParseList() |
| |
| def test_ParseScope(self): |
| parser = gn_helpers.GNValueParser('{a = 1}') |
| self.assertEqual(parser.ParseScope(), {'a': 1}) |
| |
| with self.assertRaises(gn_helpers.GNError): |
| parser = gn_helpers.GNValueParser('') # Empty. |
| parser.ParseScope() |
| with self.assertRaises(gn_helpers.GNError): |
| parser = gn_helpers.GNValueParser('asdf') # No {}. |
| parser.ParseScope() |
| with self.assertRaises(gn_helpers.GNError): |
| parser = gn_helpers.GNValueParser('{a = 1') # Unterminated. |
| parser.ParseScope() |
| with self.assertRaises(gn_helpers.GNError): |
| parser = gn_helpers.GNValueParser('{"a" = 1}') # Not identifier. |
| parser.ParseScope() |
| with self.assertRaises(gn_helpers.GNError): |
| parser = gn_helpers.GNValueParser('{a = }') # No value. |
| parser.ParseScope() |
| |
| def test_FromGNArgs(self): |
| # Booleans and numbers should work; whitespace is allowed works. |
| self.assertEqual(gn_helpers.FromGNArgs('foo = true\nbar = 1\n'), |
| {'foo': True, 'bar': 1}) |
| |
| # Whitespace is not required; strings should also work. |
| self.assertEqual(gn_helpers.FromGNArgs('foo="bar baz"'), |
| {'foo': 'bar baz'}) |
| |
| # Comments should work (and be ignored). |
| gn_args_lines = [ |
| '# Top-level comment.', |
| 'foo = true', |
| 'bar = 1 # In-line comment followed by whitespace.', |
| ' ', |
| 'baz = false', |
| ] |
| self.assertEqual(gn_helpers.FromGNArgs('\n'.join(gn_args_lines)), { |
| 'foo': True, |
| 'bar': 1, |
| 'baz': False |
| }) |
| |
| # Lists should work. |
| self.assertEqual(gn_helpers.FromGNArgs('foo=[1, 2, 3]'), |
| {'foo': [1, 2, 3]}) |
| |
| # Empty strings should return an empty dict. |
| self.assertEqual(gn_helpers.FromGNArgs(''), {}) |
| self.assertEqual(gn_helpers.FromGNArgs(' \n '), {}) |
| |
| # Comments should work everywhere (and be ignored). |
| gn_args_lines = [ |
| '# Top-level comment.', |
| '', |
| '# Variable comment.', |
| 'foo = true', |
| 'bar = [', |
| ' # Value comment in list.', |
| ' 1,', |
| ' 2,', |
| ']', |
| '', |
| 'baz # Comment anywhere, really', |
| ' = # also here', |
| ' 4', |
| ] |
| self.assertEqual(gn_helpers.FromGNArgs('\n'.join(gn_args_lines)), { |
| 'foo': True, |
| 'bar': [1, 2], |
| 'baz': 4 |
| }) |
| |
| # Scope should be parsed, even empty ones. |
| gn_args_lines = [ |
| 'foo = {', |
| ' a = 1', |
| ' b = [', |
| ' { },', |
| ' {', |
| ' c = 1', |
| ' },', |
| ' ]', |
| '}', |
| ] |
| self.assertEqual(gn_helpers.FromGNArgs('\n'.join(gn_args_lines)), |
| {'foo': { |
| 'a': 1, |
| 'b': [ |
| {}, |
| { |
| 'c': 1, |
| }, |
| ] |
| }}) |
| |
| # Non-identifiers should raise an exception. |
| with self.assertRaises(gn_helpers.GNError): |
| gn_helpers.FromGNArgs('123 = true') |
| |
| # References to other variables should raise an exception. |
| with self.assertRaises(gn_helpers.GNError): |
| gn_helpers.FromGNArgs('foo = bar') |
| |
| # References to functions should raise an exception. |
| with self.assertRaises(gn_helpers.GNError): |
| gn_helpers.FromGNArgs('foo = exec_script("//build/baz.py")') |
| |
| # Underscores in identifiers should work. |
| self.assertEqual(gn_helpers.FromGNArgs('_foo = true'), |
| {'_foo': True}) |
| self.assertEqual(gn_helpers.FromGNArgs('foo_bar = true'), |
| {'foo_bar': True}) |
| self.assertEqual(gn_helpers.FromGNArgs('foo_=true'), |
| {'foo_': True}) |
| |
| def test_ReplaceImports(self): |
| # Should be a no-op on args inputs without any imports. |
| parser = gn_helpers.GNValueParser( |
| textwrap.dedent(""" |
| some_arg1 = "val1" |
| some_arg2 = "val2" |
| """)) |
| parser.ReplaceImports() |
| self.assertEqual( |
| parser.input, |
| textwrap.dedent(""" |
| some_arg1 = "val1" |
| some_arg2 = "val2" |
| """)) |
| |
| # A single "import(...)" line should be replaced with the contents of the |
| # file being imported. |
| parser = gn_helpers.GNValueParser( |
| textwrap.dedent(""" |
| some_arg1 = "val1" |
| import("//some/args/file.gni") |
| some_arg2 = "val2" |
| """)) |
| fake_import = 'some_imported_arg = "imported_val"' |
| builtin_var = '__builtin__' if sys.version_info.major < 3 else 'builtins' |
| open_fun = '{}.open'.format(builtin_var) |
| with mock.patch(open_fun, mock.mock_open(read_data=fake_import)): |
| parser.ReplaceImports() |
| self.assertEqual( |
| parser.input, |
| textwrap.dedent(""" |
| some_arg1 = "val1" |
| some_imported_arg = "imported_val" |
| some_arg2 = "val2" |
| """)) |
| |
| # No trailing parenthesis should raise an exception. |
| with self.assertRaises(gn_helpers.GNError): |
| parser = gn_helpers.GNValueParser( |
| textwrap.dedent('import("//some/args/file.gni"')) |
| parser.ReplaceImports() |
| |
| # No double quotes should raise an exception. |
| with self.assertRaises(gn_helpers.GNError): |
| parser = gn_helpers.GNValueParser( |
| textwrap.dedent('import(//some/args/file.gni)')) |
| parser.ReplaceImports() |
| |
| # A path that's not source absolute should raise an exception. |
| with self.assertRaises(gn_helpers.GNError): |
| parser = gn_helpers.GNValueParser( |
| textwrap.dedent('import("some/relative/args/file.gni")')) |
| parser.ReplaceImports() |
| |
| def test_CreateBuildCommand(self): |
| with tempfile.TemporaryDirectory() as temp_dir: |
| suffix = '.bat' if sys.platform.startswith('win32') else '' |
| self.assertEqual(f'autoninja{suffix}', |
| gn_helpers.CreateBuildCommand(temp_dir)[0]) |
| |
| siso_deps = pathlib.Path(temp_dir) / '.siso_deps' |
| siso_deps.touch() |
| self.assertEqual(f'autoninja{suffix}', |
| gn_helpers.CreateBuildCommand(temp_dir)[0]) |
| |
| with mock.patch('shutil.which', lambda x: None): |
| cmd = gn_helpers.CreateBuildCommand(temp_dir) |
| self.assertIn('third_party', cmd[0]) |
| self.assertIn(f'{os.sep}siso', cmd[0]) |
| self.assertEqual(['ninja', '-C', temp_dir], cmd[1:]) |
| |
| ninja_deps = pathlib.Path(temp_dir) / '.ninja_deps' |
| ninja_deps.touch() |
| |
| with self.assertRaisesRegex(Exception, 'Found both'): |
| gn_helpers.CreateBuildCommand(temp_dir) |
| |
| siso_deps.unlink() |
| self.assertEqual(f'autoninja{suffix}', |
| gn_helpers.CreateBuildCommand(temp_dir)[0]) |
| |
| with mock.patch('shutil.which', lambda x: None): |
| cmd = gn_helpers.CreateBuildCommand(temp_dir) |
| self.assertIn('third_party', cmd[0]) |
| self.assertIn(f'{os.sep}ninja', cmd[0]) |
| self.assertEqual(['-C', temp_dir], cmd[1:]) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |