def test_objdir_path(self): config = self.config ctxt = Context(config=config) ctxt.push_source(mozpath.join(config.topsrcdir, 'foo', 'moz.build')) path = ObjDirPath(ctxt, '!qux') self.assertEqual(path, '!qux') self.assertEqual(path.full_path, mozpath.join(config.topobjdir, 'foo', 'qux')) path = ObjDirPath(ctxt, '!../bar/qux') self.assertEqual(path, '!../bar/qux') self.assertEqual(path.full_path, mozpath.join(config.topobjdir, 'bar', 'qux')) path = ObjDirPath(ctxt, '!/qux/qux') self.assertEqual(path, '!/qux/qux') self.assertEqual(path.full_path, mozpath.join(config.topobjdir, 'qux', 'qux')) with self.assertRaises(ValueError): path = ObjDirPath(ctxt, '../bar/qux') with self.assertRaises(ValueError): path = ObjDirPath(ctxt, '/qux/qux') path = ObjDirPath(path) self.assertIsInstance(path, ObjDirPath) self.assertEqual(path, '!/qux/qux') self.assertEqual(path.full_path, mozpath.join(config.topobjdir, 'qux', 'qux')) path = Path(path) self.assertIsInstance(path, ObjDirPath)
def test_objdir_path(self): config = self.config ctxt = Context(config=config) ctxt.push_source(mozpath.join(config.topsrcdir, "foo", "moz.build")) path = ObjDirPath(ctxt, "!qux") self.assertEqual(path, "!qux") self.assertEqual(path.full_path, mozpath.join(config.topobjdir, "foo", "qux")) path = ObjDirPath(ctxt, "!../bar/qux") self.assertEqual(path, "!../bar/qux") self.assertEqual(path.full_path, mozpath.join(config.topobjdir, "bar", "qux")) path = ObjDirPath(ctxt, "!/qux/qux") self.assertEqual(path, "!/qux/qux") self.assertEqual(path.full_path, mozpath.join(config.topobjdir, "qux", "qux")) with self.assertRaises(ValueError): path = ObjDirPath(ctxt, "../bar/qux") with self.assertRaises(ValueError): path = ObjDirPath(ctxt, "/qux/qux") path = ObjDirPath(path) self.assertIsInstance(path, ObjDirPath) self.assertEqual(path, "!/qux/qux") self.assertEqual(path.full_path, mozpath.join(config.topobjdir, "qux", "qux")) path = Path(path) self.assertIsInstance(path, ObjDirPath)
def test_absolute_path(self): config = self.config ctxt = Context(config=config) ctxt.push_source(mozpath.join(config.topsrcdir, 'foo', 'moz.build')) path = AbsolutePath(ctxt, '%/qux') self.assertEqual(path, '%/qux') self.assertEqual(path.full_path, '/qux') with self.assertRaises(ValueError): path = AbsolutePath(ctxt, '%qux')
def test_absolute_path(self): config = self.config ctxt = Context(config=config) ctxt.push_source(mozpath.join(config.topsrcdir, "foo", "moz.build")) path = AbsolutePath(ctxt, "%/qux") self.assertEqual(path, "%/qux") self.assertEqual(path.full_path, "/qux") with self.assertRaises(ValueError): path = AbsolutePath(ctxt, "%qux")
def test_path_typed_list(self): config = self.config ctxt1 = Context(config=config) ctxt1.push_source(mozpath.join(config.topsrcdir, "foo", "moz.build")) ctxt2 = Context(config=config) ctxt2.push_source(mozpath.join(config.topsrcdir, "bar", "moz.build")) paths = [ "!../bar/qux", "!/qux/qux", "!qux", "../bar/qux", "/qux/qux", "qux", ] MyList = ContextDerivedTypedList(Path) l = MyList(ctxt1) l += paths for p_str, p_path in zip(paths, l): self.assertEqual(p_str, p_path) self.assertEqual(p_path, Path(ctxt1, p_str)) self.assertEqual(p_path.join("foo"), Path(ctxt1, mozpath.join(p_str, "foo"))) l2 = MyList(ctxt2) l2 += paths for p_str, p_path in zip(paths, l2): self.assertEqual(p_str, p_path) self.assertEqual(p_path, Path(ctxt2, p_str)) # Assigning with Paths from another context doesn't rebase them l2 = MyList(ctxt2) l2 += l for p_str, p_path in zip(paths, l2): self.assertEqual(p_str, p_path) self.assertEqual(p_path, Path(ctxt1, p_str)) MyListWithFlags = ContextDerivedTypedListWithItems( Path, StrictOrderingOnAppendListWithFlagsFactory({ "foo": bool, }), ) l = MyListWithFlags(ctxt1) l += paths for p in paths: l[p].foo = True for p_str, p_path in zip(paths, l): self.assertEqual(p_str, p_path) self.assertEqual(p_path, Path(ctxt1, p_str)) self.assertEqual(l[p_str].foo, True) self.assertEqual(l[p_path].foo, True)
def test_key_checking(self): # Checking for existence of a key should not populate the key if it # doesn't exist. g = Context(allowed_variables=VARIABLES) self.assertFalse('HOGE' in g) self.assertFalse('HOGE' in g)
def test_allowed_set(self): self.assertIn('HOGE', VARIABLES) ns = Context(allowed_variables=VARIABLES) ns['HOGE'] = 'foo' self.assertEqual(ns['HOGE'], 'foo')
def test_allowed_set(self): self.assertIn("HOGE", VARIABLES) ns = Context(allowed_variables=VARIABLES) ns["HOGE"] = "foo" self.assertEqual(ns["HOGE"], "foo")
def test_exec_source_reassign_exported(self): template_sandbox = self.sandbox(data_path='templates') # Templates need to be defined in actual files because of # inspect.getsourcelines. template_sandbox.exec_file('templates.mozbuild') config = MockConfig() exports = {'DIST_SUBDIR': 'browser'} sandbox = TestedSandbox(Context(VARIABLES, config), metadata={ 'exports': exports, 'templates': template_sandbox.templates, }) self.assertEqual(sandbox['DIST_SUBDIR'], 'browser') # Templates should not interfere sandbox.exec_source('Template([])', 'foo.mozbuild') sandbox.exec_source('DIST_SUBDIR = "foo"') with self.assertRaises(SandboxExecutionError) as se: sandbox.exec_source('DIST_SUBDIR = "bar"') self.assertEqual(sandbox['DIST_SUBDIR'], 'foo') e = se.exception self.assertIsInstance(e.exc_value, KeyError) e = se.exception.exc_value self.assertEqual(e.args[0], 'global_ns') self.assertEqual(e.args[1], 'reassign') self.assertEqual(e.args[2], 'DIST_SUBDIR')
def sandbox(self): return Sandbox( Context( { "DIRS": (list, list, None), } ) )
def test_defaults(self): test = Context({ 'foo': (int, int, '', None), 'bar': (bool, bool, '', None), 'baz': (dict, dict, '', None), }) self.assertEqual(test.keys(), []) self.assertEqual(test['foo'], 0) self.assertEqual(set(test.keys()), {'foo'}) self.assertEqual(test['bar'], False) self.assertEqual(set(test.keys()), {'foo', 'bar'}) self.assertEqual(test['baz'], {}) self.assertEqual(set(test.keys()), {'foo', 'bar', 'baz'}) with self.assertRaises(KeyError): test['qux'] self.assertEqual(set(test.keys()), {'foo', 'bar', 'baz'})
def sandbox(self, data_path=None, metadata={}): config = None if data_path is not None: config = MockConfig(mozpath.join(test_data_path, data_path)) else: config = MockConfig() return TestedSandbox(Context(VARIABLES, config), metadata)
def test_aggregate_empty(self): c = Context({}) files = {'moz.build': Files(c, '**')} self.assertEqual(Files.aggregate(files), { 'bug_component_counts': [], 'recommended_bug_component': None, })
def test_path_with_mixed_contexts(self): config = self.config ctxt1 = Context(config=config) ctxt1.push_source(mozpath.join(config.topsrcdir, "foo", "moz.build")) ctxt2 = Context(config=config) ctxt2.push_source(mozpath.join(config.topsrcdir, "bar", "moz.build")) path1 = Path(ctxt1, "qux") path2 = Path(ctxt2, path1) self.assertEqual(path2, path1) self.assertEqual(path2, "qux") self.assertEqual(path2.context, ctxt1) self.assertEqual(path2.full_path, mozpath.join(config.topsrcdir, "foo", "qux")) path1 = Path(ctxt1, "../bar/qux") path2 = Path(ctxt2, path1) self.assertEqual(path2, path1) self.assertEqual(path2, "../bar/qux") self.assertEqual(path2.context, ctxt1) self.assertEqual(path2.full_path, mozpath.join(config.topsrcdir, "bar", "qux")) path1 = Path(ctxt1, "/qux/qux") path2 = Path(ctxt2, path1) self.assertEqual(path2, path1) self.assertEqual(path2, "/qux/qux") self.assertEqual(path2.context, ctxt1) self.assertEqual(path2.full_path, mozpath.join(config.topsrcdir, "qux", "qux")) path1 = Path(ctxt1, "!qux") path2 = Path(ctxt2, path1) self.assertEqual(path2, path1) self.assertEqual(path2, "!qux") self.assertEqual(path2.context, ctxt1) self.assertEqual(path2.full_path, mozpath.join(config.topobjdir, "foo", "qux")) path1 = Path(ctxt1, "!../bar/qux") path2 = Path(ctxt2, path1) self.assertEqual(path2, path1) self.assertEqual(path2, "!../bar/qux") self.assertEqual(path2.context, ctxt1) self.assertEqual(path2.full_path, mozpath.join(config.topobjdir, "bar", "qux")) path1 = Path(ctxt1, "!/qux/qux") path2 = Path(ctxt2, path1) self.assertEqual(path2, path1) self.assertEqual(path2, "!/qux/qux") self.assertEqual(path2.context, ctxt1) self.assertEqual(path2.full_path, mozpath.join(config.topobjdir, "qux", "qux"))
def test_path_with_mixed_contexts(self): config = self.config ctxt1 = Context(config=config) ctxt1.push_source(mozpath.join(config.topsrcdir, 'foo', 'moz.build')) ctxt2 = Context(config=config) ctxt2.push_source(mozpath.join(config.topsrcdir, 'bar', 'moz.build')) path1 = Path(ctxt1, 'qux') path2 = Path(ctxt2, path1) self.assertEqual(path2, path1) self.assertEqual(path2, 'qux') self.assertEqual(path2.context, ctxt1) self.assertEqual(path2.full_path, mozpath.join(config.topsrcdir, 'foo', 'qux')) path1 = Path(ctxt1, '../bar/qux') path2 = Path(ctxt2, path1) self.assertEqual(path2, path1) self.assertEqual(path2, '../bar/qux') self.assertEqual(path2.context, ctxt1) self.assertEqual(path2.full_path, mozpath.join(config.topsrcdir, 'bar', 'qux')) path1 = Path(ctxt1, '/qux/qux') path2 = Path(ctxt2, path1) self.assertEqual(path2, path1) self.assertEqual(path2, '/qux/qux') self.assertEqual(path2.context, ctxt1) self.assertEqual(path2.full_path, mozpath.join(config.topsrcdir, 'qux', 'qux')) path1 = Path(ctxt1, '!qux') path2 = Path(ctxt2, path1) self.assertEqual(path2, path1) self.assertEqual(path2, '!qux') self.assertEqual(path2.context, ctxt1) self.assertEqual(path2.full_path, mozpath.join(config.topobjdir, 'foo', 'qux')) path1 = Path(ctxt1, '!../bar/qux') path2 = Path(ctxt2, path1) self.assertEqual(path2, path1) self.assertEqual(path2, '!../bar/qux') self.assertEqual(path2.context, ctxt1) self.assertEqual(path2.full_path, mozpath.join(config.topobjdir, 'bar', 'qux')) path1 = Path(ctxt1, '!/qux/qux') path2 = Path(ctxt2, path1) self.assertEqual(path2, path1) self.assertEqual(path2, '!/qux/qux') self.assertEqual(path2.context, ctxt1) self.assertEqual(path2.full_path, mozpath.join(config.topobjdir, 'qux', 'qux'))
def test_invalid_utf8_substs(self): """Ensure invalid UTF-8 in substs is converted with an error.""" # This is really mbcs. It's a bunch of invalid UTF-8. config = MockConfig(extra_substs={'BAD_UTF8': b'\x83\x81\x83\x82\x3A'}) sandbox = MozbuildSandbox(Context(VARIABLES, config)) self.assertEqual(sandbox['CONFIG']['BAD_UTF8'], u'\ufffd\ufffd\ufffd\ufffd:')
def test_single_bug_component(self): c = Context({}) f = Files(c, '**') f['BUG_COMPONENT'] = (u'Product1', u'Component1') files = {'moz.build': f} self.assertEqual(Files.aggregate(files), { 'bug_component_counts': [((u'Product1', u'Component1'), 1)], 'recommended_bug_component': (u'Product1', u'Component1'), })
def test_dirs(self): class Config(object): pass config = Config() config.topsrcdir = mozpath.abspath(os.curdir) config.topobjdir = mozpath.abspath('obj') test = Context(config=config) foo = mozpath.abspath('foo') test.push_source(foo) self.assertEqual(test.srcdir, config.topsrcdir) self.assertEqual(test.relsrcdir, '') self.assertEqual(test.objdir, config.topobjdir) self.assertEqual(test.relobjdir, '') foobar = os.path.abspath('foo/bar') test.push_source(foobar) self.assertEqual(test.srcdir, mozpath.join(config.topsrcdir, 'foo')) self.assertEqual(test.relsrcdir, 'foo') self.assertEqual(test.objdir, config.topobjdir) self.assertEqual(test.relobjdir, '')
def test_aggregate_empty(self): c = Context({}) files = {"moz.build": Files(c, "**")} self.assertEqual( Files.aggregate(files), { "bug_component_counts": [], "recommended_bug_component": None, }, )
def test_defaults(self): test = Context({ "foo": (int, int, ""), "bar": (bool, bool, ""), "baz": (dict, dict, ""), }) self.assertEqual(list(test), []) self.assertEqual(test["foo"], 0) self.assertEqual(set(test.keys()), {"foo"}) self.assertEqual(test["bar"], False) self.assertEqual(set(test.keys()), {"foo", "bar"}) self.assertEqual(test["baz"], {}) self.assertEqual(set(test.keys()), {"foo", "bar", "baz"}) with self.assertRaises(KeyError): test["qux"] self.assertEqual(set(test.keys()), {"foo", "bar", "baz"})
def test_defaults(self): test = Context({ 'foo': (int, int, '', None), 'bar': (bool, bool, '', None), 'baz': (dict, dict, '', None), }) self.assertEqual(test.keys(), []) self.assertEqual(test['foo'], 0) self.assertEqual(set(test.keys()), { 'foo' }) self.assertEqual(test['bar'], False) self.assertEqual(set(test.keys()), { 'foo', 'bar' }) self.assertEqual(test['baz'], {}) self.assertEqual(set(test.keys()), { 'foo', 'bar', 'baz' }) with self.assertRaises(KeyError): test['qux'] self.assertEqual(set(test.keys()), { 'foo', 'bar', 'baz' })
def test_single_bug_component(self): c = Context({}) f = Files(c, "**") f["BUG_COMPONENT"] = ("Product1", "Component1") files = {"moz.build": f} self.assertEqual( Files.aggregate(files), { "bug_component_counts": [(("Product1", "Component1"), 1)], "recommended_bug_component": ("Product1", "Component1"), }, )
def test_value_checking(self): ns = Context(allowed_variables=VARIABLES) # Setting to a non-allowed type should not work. with self.assertRaises(ValueError) as ve: ns["HOGE"] = True e = ve.exception.args self.assertEqual(e[0], "global_ns") self.assertEqual(e[1], "set_type") self.assertEqual(e[2], "HOGE") self.assertEqual(e[3], True) self.assertEqual(e[4], six.text_type)
def test_value_checking(self): ns = Context(allowed_variables=VARIABLES) # Setting to a non-allowed type should not work. with self.assertRaises(ValueError) as ve: ns['HOGE'] = True e = ve.exception.args self.assertEqual(e[0], 'global_ns') self.assertEqual(e[1], 'set_type') self.assertEqual(e[2], 'HOGE') self.assertEqual(e[3], True) self.assertEqual(e[4], unicode)
def test_path_typed_list(self): config = self.config ctxt1 = Context(config=config) ctxt1.push_source(mozpath.join(config.topsrcdir, 'foo', 'moz.build')) ctxt2 = Context(config=config) ctxt2.push_source(mozpath.join(config.topsrcdir, 'bar', 'moz.build')) paths = [ '!../bar/qux', '!/qux/qux', '!qux', '../bar/qux', '/qux/qux', 'qux', ] MyList = ContextDerivedTypedList(Path) l = MyList(ctxt1) l += paths for p_str, p_path in zip(paths, l): self.assertEqual(p_str, p_path) self.assertEqual(p_path, Path(ctxt1, p_str)) self.assertEqual(p_path.join('foo'), Path(ctxt1, mozpath.join(p_str, 'foo'))) l2 = MyList(ctxt2) l2 += paths for p_str, p_path in zip(paths, l2): self.assertEqual(p_str, p_path) self.assertEqual(p_path, Path(ctxt2, p_str)) # Assigning with Paths from another context doesn't rebase them l2 = MyList(ctxt2) l2 += l for p_str, p_path in zip(paths, l2): self.assertEqual(p_str, p_path) self.assertEqual(p_path, Path(ctxt1, p_str)) MyListWithFlags = ContextDerivedTypedListWithItems( Path, StrictOrderingOnAppendListWithFlagsFactory({ 'foo': bool, })) l = MyListWithFlags(ctxt1) l += paths for p in paths: l[p].foo = True for p_str, p_path in zip(paths, l): self.assertEqual(p_str, p_path) self.assertEqual(p_path, Path(ctxt1, p_str)) self.assertEqual(l[p_str].foo, True) self.assertEqual(l[p_path].foo, True)
def test_multiple_patterns(self): c = Context({}) f1 = Files(c, 'a/**') f1['BUG_COMPONENT'] = (u'Product1', u'Component1') f2 = Files(c, 'b/**', 'a/bar') f2['BUG_COMPONENT'] = (u'Product2', u'Component2') files = {'a/foo': f1, 'a/bar': f2, 'b/foo': f2} self.assertEqual(Files.aggregate(files), { 'bug_component_counts': [ ((u'Product2', u'Component2'), 2), ((u'Product1', u'Component1'), 1), ], 'recommended_bug_component': (u'Product2', u'Component2'), })
def test_path_typed_hierarchy_list(self): config = self.config ctxt1 = Context(config=config) ctxt1.push_source(mozpath.join(config.topsrcdir, 'foo', 'moz.build')) ctxt2 = Context(config=config) ctxt2.push_source(mozpath.join(config.topsrcdir, 'bar', 'moz.build')) paths = [ '!../bar/qux', '!/qux/qux', '!qux', '../bar/qux', '/qux/qux', 'qux', ] MyList = ContextDerivedTypedHierarchicalStringList(Path) l = MyList(ctxt1) l += paths l.subdir += paths for _, files in l.walk(): for p_str, p_path in zip(paths, files): self.assertEqual(p_str, p_path) self.assertEqual(p_path, Path(ctxt1, p_str)) self.assertEqual(p_path.join('foo'), Path(ctxt1, mozpath.join(p_str, 'foo'))) l2 = MyList(ctxt2) l2 += paths l2.subdir += paths for _, files in l2.walk(): for p_str, p_path in zip(paths, files): self.assertEqual(p_str, p_path) self.assertEqual(p_path, Path(ctxt2, p_str)) # Assigning with Paths from another context doesn't rebase them l2 = MyList(ctxt2) l2 += l for _, files in l2.walk(): for p_str, p_path in zip(paths, files): self.assertEqual(p_str, p_path) self.assertEqual(p_path, Path(ctxt1, p_str))
def test_no_recommended_bug_component(self): """If there is no clear count winner, we don't recommend a bug component.""" c = Context({}) f1 = Files(c, '**') f1['BUG_COMPONENT'] = (u'Product1', u'Component1') f2 = Files(c, '**') f2['BUG_COMPONENT'] = (u'Product2', u'Component2') files = {'a': f1, 'b': f2} self.assertEqual(Files.aggregate(files), { 'bug_component_counts': [ ((u'Product1', u'Component1'), 1), ((u'Product2', u'Component2'), 1), ], 'recommended_bug_component': None, })
def test_context_derived_typed_list(self): ns = Context(allowed_variables=VARIABLES) # Setting to a type that's rejected by coercion should not work. with self.assertRaises(ValueError): ns['HOGERA'] = [False] ns['HOGERA'] += ['a', 'b', 'c'] self.assertIsInstance(ns['HOGERA'], VARIABLES['HOGERA'][0]) for n in range(0, 3): self.assertIsInstance(ns['HOGERA'][n], Piyo) self.assertEqual(ns['HOGERA'][n].value, ['a', 'b', 'c'][n]) self.assertEqual(ns['HOGERA'][n].context, ns) with self.assertRaises(UnsortedError): ns['HOGERA'] += ['f', 'e', 'd']
def test_context_derived_typed_list(self): ns = Context(allowed_variables=VARIABLES) # Setting to a type that's rejected by coercion should not work. with self.assertRaises(ValueError): ns["HOGERA"] = [False] ns["HOGERA"] += ["a", "b", "c"] self.assertIsInstance(ns["HOGERA"], VARIABLES["HOGERA"][0]) for n in range(0, 3): self.assertIsInstance(ns["HOGERA"][n], Piyo) self.assertEqual(ns["HOGERA"][n].value, ["a", "b", "c"][n]) self.assertEqual(ns["HOGERA"][n].context, ns) with self.assertRaises(UnsortedError): ns["HOGERA"] += ["f", "e", "d"]
def test_multiple_patterns(self): c = Context({}) f1 = Files(c, "a/**") f1["BUG_COMPONENT"] = ("Product1", "Component1") f2 = Files(c, "b/**", "a/bar") f2["BUG_COMPONENT"] = ("Product2", "Component2") files = {"a/foo": f1, "a/bar": f2, "b/foo": f2} self.assertEqual( Files.aggregate(files), { "bug_component_counts": [ (("Product2", "Component2"), 2), (("Product1", "Component1"), 1), ], "recommended_bug_component": ("Product2", "Component2"), }, )
def test_type_check(self): test = Context({ 'foo': (int, int, ''), 'baz': (dict, list, ''), }) test['foo'] = 5 self.assertEqual(test['foo'], 5) with self.assertRaises(ValueError): test['foo'] = {} self.assertEqual(test['foo'], 5) with self.assertRaises(KeyError): test['bar'] = True test['baz'] = [('a', 1), ('b', 2)] self.assertEqual(test['baz'], {'a': 1, 'b': 2})
def test_no_recommended_bug_component(self): """If there is no clear count winner, we don't recommend a bug component.""" c = Context({}) f1 = Files(c, "**") f1["BUG_COMPONENT"] = ("Product1", "Component1") f2 = Files(c, "**") f2["BUG_COMPONENT"] = ("Product2", "Component2") files = {"a": f1, "b": f2} self.assertEqual( Files.aggregate(files), { "bug_component_counts": [ (("Product1", "Component1"), 1), (("Product2", "Component2"), 1), ], "recommended_bug_component": None, }, )
def test_defaults(self): test = Context({"foo": (int, int, "", None), "bar": (bool, bool, "", None), "baz": (dict, dict, "", None)}) self.assertEqual(test.keys(), []) self.assertEqual(test["foo"], 0) self.assertEqual(set(test.keys()), {"foo"}) self.assertEqual(test["bar"], False) self.assertEqual(set(test.keys()), {"foo", "bar"}) self.assertEqual(test["baz"], {}) self.assertEqual(set(test.keys()), {"foo", "bar", "baz"}) with self.assertRaises(KeyError): test["qux"] self.assertEqual(set(test.keys()), {"foo", "bar", "baz"})
def test_context_paths(self): test = Context() # Newly created context has no paths. self.assertIsNone(test.main_path) self.assertIsNone(test.current_path) self.assertEqual(test.all_paths, set()) self.assertEqual(test.source_stack, []) foo = os.path.abspath("foo") test.add_source(foo) # Adding the first source makes it the main and current path. self.assertEqual(test.main_path, foo) self.assertEqual(test.current_path, foo) self.assertEqual(test.all_paths, set([foo])) self.assertEqual(test.source_stack, [foo]) bar = os.path.abspath("bar") test.add_source(bar) # Adding the second source makes leaves main and current paths alone. self.assertEqual(test.main_path, foo) self.assertEqual(test.current_path, foo) self.assertEqual(test.all_paths, set([bar, foo])) self.assertEqual(test.source_stack, [foo]) qux = os.path.abspath("qux") test.push_source(qux) # Pushing a source makes it the current path self.assertEqual(test.main_path, foo) self.assertEqual(test.current_path, qux) self.assertEqual(test.all_paths, set([bar, foo, qux])) self.assertEqual(test.source_stack, [foo, qux]) hoge = os.path.abspath("hoge") test.push_source(hoge) self.assertEqual(test.main_path, foo) self.assertEqual(test.current_path, hoge) self.assertEqual(test.all_paths, set([bar, foo, hoge, qux])) self.assertEqual(test.source_stack, [foo, qux, hoge]) fuga = os.path.abspath("fuga") # Adding a source after pushing doesn't change the source stack test.add_source(fuga) self.assertEqual(test.main_path, foo) self.assertEqual(test.current_path, hoge) self.assertEqual(test.all_paths, set([bar, foo, fuga, hoge, qux])) self.assertEqual(test.source_stack, [foo, qux, hoge]) # Adding a source twice doesn't change anything test.add_source(qux) self.assertEqual(test.main_path, foo) self.assertEqual(test.current_path, hoge) self.assertEqual(test.all_paths, set([bar, foo, fuga, hoge, qux])) self.assertEqual(test.source_stack, [foo, qux, hoge]) last = test.pop_source() # Popping a source returns the last pushed one, not the last added one. self.assertEqual(last, hoge) self.assertEqual(test.main_path, foo) self.assertEqual(test.current_path, qux) self.assertEqual(test.all_paths, set([bar, foo, fuga, hoge, qux])) self.assertEqual(test.source_stack, [foo, qux]) last = test.pop_source() self.assertEqual(last, qux) self.assertEqual(test.main_path, foo) self.assertEqual(test.current_path, foo) self.assertEqual(test.all_paths, set([bar, foo, fuga, hoge, qux])) self.assertEqual(test.source_stack, [foo]) # Popping the main path is allowed. last = test.pop_source() self.assertEqual(last, foo) self.assertEqual(test.main_path, foo) self.assertIsNone(test.current_path) self.assertEqual(test.all_paths, set([bar, foo, fuga, hoge, qux])) self.assertEqual(test.source_stack, []) # Popping past the main path asserts. with self.assertRaises(AssertionError): test.pop_source() # Pushing after the main path was popped asserts. with self.assertRaises(AssertionError): test.push_source(foo) test = Context() test.push_source(foo) test.push_source(bar) # Pushing the same file twice is allowed. test.push_source(bar) test.push_source(foo) self.assertEqual(last, foo) self.assertEqual(test.main_path, foo) self.assertEqual(test.current_path, foo) self.assertEqual(test.all_paths, set([bar, foo])) self.assertEqual(test.source_stack, [foo, bar, bar, foo])
def test_update(self): test = Context({"foo": (int, int, "", None), "bar": (bool, bool, "", None), "baz": (dict, list, "", None)}) self.assertEqual(test.keys(), []) with self.assertRaises(ValueError): test.update(bar=True, foo={}) self.assertEqual(test.keys(), []) test.update(bar=True, foo=1) self.assertEqual(set(test.keys()), {"foo", "bar"}) self.assertEqual(test["foo"], 1) self.assertEqual(test["bar"], True) test.update([("bar", False), ("foo", 2)]) self.assertEqual(test["foo"], 2) self.assertEqual(test["bar"], False) test.update([("foo", 0), ("baz", {"a": 1, "b": 2})]) self.assertEqual(test["foo"], 0) self.assertEqual(test["baz"], {"a": 1, "b": 2}) test.update([("foo", 42), ("baz", [("c", 3), ("d", 4)])]) self.assertEqual(test["foo"], 42) self.assertEqual(test["baz"], {"c": 3, "d": 4})
def test_path(self): config = self.config ctxt1 = Context(config=config) ctxt1.push_source(mozpath.join(config.topsrcdir, "foo", "moz.build")) ctxt2 = Context(config=config) ctxt2.push_source(mozpath.join(config.topsrcdir, "bar", "moz.build")) path1 = Path(ctxt1, "qux") self.assertIsInstance(path1, SourcePath) self.assertEqual(path1, "qux") self.assertEqual(path1.full_path, mozpath.join(config.topsrcdir, "foo", "qux")) path2 = Path(ctxt2, "../foo/qux") self.assertIsInstance(path2, SourcePath) self.assertEqual(path2, "../foo/qux") self.assertEqual(path2.full_path, mozpath.join(config.topsrcdir, "foo", "qux")) self.assertEqual(path1, path2) self.assertEqual(path1.join("../../bar/qux").full_path, mozpath.join(config.topsrcdir, "bar", "qux")) path1 = Path(ctxt1, "/qux/qux") self.assertIsInstance(path1, SourcePath) self.assertEqual(path1, "/qux/qux") self.assertEqual(path1.full_path, mozpath.join(config.topsrcdir, "qux", "qux")) path2 = Path(ctxt2, "/qux/qux") self.assertIsInstance(path2, SourcePath) self.assertEqual(path2, "/qux/qux") self.assertEqual(path2.full_path, mozpath.join(config.topsrcdir, "qux", "qux")) self.assertEqual(path1, path2) path1 = Path(ctxt1, "!qux") self.assertIsInstance(path1, ObjDirPath) self.assertEqual(path1, "!qux") self.assertEqual(path1.full_path, mozpath.join(config.topobjdir, "foo", "qux")) path2 = Path(ctxt2, "!../foo/qux") self.assertIsInstance(path2, ObjDirPath) self.assertEqual(path2, "!../foo/qux") self.assertEqual(path2.full_path, mozpath.join(config.topobjdir, "foo", "qux")) self.assertEqual(path1, path2) path1 = Path(ctxt1, "!/qux/qux") self.assertIsInstance(path1, ObjDirPath) self.assertEqual(path1, "!/qux/qux") self.assertEqual(path1.full_path, mozpath.join(config.topobjdir, "qux", "qux")) path2 = Path(ctxt2, "!/qux/qux") self.assertIsInstance(path2, ObjDirPath) self.assertEqual(path2, "!/qux/qux") self.assertEqual(path2.full_path, mozpath.join(config.topobjdir, "qux", "qux")) self.assertEqual(path1, path2) path1 = Path(ctxt1, path1) self.assertIsInstance(path1, ObjDirPath) self.assertEqual(path1, "!/qux/qux") self.assertEqual(path1.full_path, mozpath.join(config.topobjdir, "qux", "qux")) path2 = Path(ctxt2, path2) self.assertIsInstance(path2, ObjDirPath) self.assertEqual(path2, "!/qux/qux") self.assertEqual(path2.full_path, mozpath.join(config.topobjdir, "qux", "qux")) self.assertEqual(path1, path2) path1 = Path(path1) self.assertIsInstance(path1, ObjDirPath) self.assertEqual(path1, "!/qux/qux") self.assertEqual(path1.full_path, mozpath.join(config.topobjdir, "qux", "qux")) self.assertEqual(path1, path2) path2 = Path(path2) self.assertIsInstance(path2, ObjDirPath) self.assertEqual(path2, "!/qux/qux") self.assertEqual(path2.full_path, mozpath.join(config.topobjdir, "qux", "qux")) self.assertEqual(path1, path2)
def test_update(self): test = Context({ 'foo': (int, int, '', None), 'bar': (bool, bool, '', None), 'baz': (dict, list, '', None), }) self.assertEqual(test.keys(), []) with self.assertRaises(ValueError): test.update(bar=True, foo={}) self.assertEqual(test.keys(), []) test.update(bar=True, foo=1) self.assertEqual(set(test.keys()), { 'foo', 'bar' }) self.assertEqual(test['foo'], 1) self.assertEqual(test['bar'], True) test.update([('bar', False), ('foo', 2)]) self.assertEqual(test['foo'], 2) self.assertEqual(test['bar'], False) test.update([('foo', 0), ('baz', { 'a': 1, 'b': 2 })]) self.assertEqual(test['foo'], 0) self.assertEqual(test['baz'], { 'a': 1, 'b': 2 }) test.update([('foo', 42), ('baz', [('c', 3), ('d', 4)])]) self.assertEqual(test['foo'], 42) self.assertEqual(test['baz'], { 'c': 3, 'd': 4 })
def test_path(self): config = self.config ctxt1 = Context(config=config) ctxt1.push_source(mozpath.join(config.topsrcdir, 'foo', 'moz.build')) ctxt2 = Context(config=config) ctxt2.push_source(mozpath.join(config.topsrcdir, 'bar', 'moz.build')) path1 = Path(ctxt1, 'qux') self.assertIsInstance(path1, SourcePath) self.assertEqual(path1, 'qux') self.assertEqual(path1.full_path, mozpath.join(config.topsrcdir, 'foo', 'qux')) path2 = Path(ctxt2, '../foo/qux') self.assertIsInstance(path2, SourcePath) self.assertEqual(path2, '../foo/qux') self.assertEqual(path2.full_path, mozpath.join(config.topsrcdir, 'foo', 'qux')) self.assertEqual(path1, path2) self.assertEqual(path1.join('../../bar/qux').full_path, mozpath.join(config.topsrcdir, 'bar', 'qux')) path1 = Path(ctxt1, '/qux/qux') self.assertIsInstance(path1, SourcePath) self.assertEqual(path1, '/qux/qux') self.assertEqual(path1.full_path, mozpath.join(config.topsrcdir, 'qux', 'qux')) path2 = Path(ctxt2, '/qux/qux') self.assertIsInstance(path2, SourcePath) self.assertEqual(path2, '/qux/qux') self.assertEqual(path2.full_path, mozpath.join(config.topsrcdir, 'qux', 'qux')) self.assertEqual(path1, path2) path1 = Path(ctxt1, '!qux') self.assertIsInstance(path1, ObjDirPath) self.assertEqual(path1, '!qux') self.assertEqual(path1.full_path, mozpath.join(config.topobjdir, 'foo', 'qux')) path2 = Path(ctxt2, '!../foo/qux') self.assertIsInstance(path2, ObjDirPath) self.assertEqual(path2, '!../foo/qux') self.assertEqual(path2.full_path, mozpath.join(config.topobjdir, 'foo', 'qux')) self.assertEqual(path1, path2) path1 = Path(ctxt1, '!/qux/qux') self.assertIsInstance(path1, ObjDirPath) self.assertEqual(path1, '!/qux/qux') self.assertEqual(path1.full_path, mozpath.join(config.topobjdir, 'qux', 'qux')) path2 = Path(ctxt2, '!/qux/qux') self.assertIsInstance(path2, ObjDirPath) self.assertEqual(path2, '!/qux/qux') self.assertEqual(path2.full_path, mozpath.join(config.topobjdir, 'qux', 'qux')) self.assertEqual(path1, path2) path1 = Path(ctxt1, path1) self.assertIsInstance(path1, ObjDirPath) self.assertEqual(path1, '!/qux/qux') self.assertEqual(path1.full_path, mozpath.join(config.topobjdir, 'qux', 'qux')) path2 = Path(ctxt2, path2) self.assertIsInstance(path2, ObjDirPath) self.assertEqual(path2, '!/qux/qux') self.assertEqual(path2.full_path, mozpath.join(config.topobjdir, 'qux', 'qux')) self.assertEqual(path1, path2) path1 = Path(path1) self.assertIsInstance(path1, ObjDirPath) self.assertEqual(path1, '!/qux/qux') self.assertEqual(path1.full_path, mozpath.join(config.topobjdir, 'qux', 'qux')) self.assertEqual(path1, path2) path2 = Path(path2) self.assertIsInstance(path2, ObjDirPath) self.assertEqual(path2, '!/qux/qux') self.assertEqual(path2.full_path, mozpath.join(config.topobjdir, 'qux', 'qux')) self.assertEqual(path1, path2)
def _consume_jar_manifest(self, obj): # Ideally, this would all be handled somehow in the emitter, but # this would require all the magic surrounding l10n and addons in # the recursive make backend to die, which is not going to happen # any time soon enough. # Notably missing: # - DEFINES from config/config.mk # - L10n support # - The equivalent of -e when USE_EXTENSION_MANIFEST is set in # moz.build, but it doesn't matter in dist/bin. pp = Preprocessor() if obj.defines: pp.context.update(obj.defines.defines) pp.context.update(self.environment.defines) pp.context.update( AB_CD='en-US', BUILD_FASTER=1, ) pp.out = JarManifestParser() try: pp.do_include(obj.path.full_path) except DeprecatedJarManifest as e: raise DeprecatedJarManifest('Parsing error while processing %s: %s' % (obj.path.full_path, e.message)) self.backend_input_files |= pp.includes for jarinfo in pp.out: jar_context = Context( allowed_variables=VARIABLES, config=obj._context.config) jar_context.push_source(obj._context.main_path) jar_context.push_source(obj.path.full_path) install_target = obj.install_target if jarinfo.base: install_target = mozpath.normpath( mozpath.join(install_target, jarinfo.base)) jar_context['FINAL_TARGET'] = install_target if obj.defines: jar_context['DEFINES'] = obj.defines.defines files = jar_context['FINAL_TARGET_FILES'] files_pp = jar_context['FINAL_TARGET_PP_FILES'] for e in jarinfo.entries: if e.is_locale: if jarinfo.relativesrcdir: src = '/%s' % jarinfo.relativesrcdir else: src = '' src = mozpath.join(src, 'en-US', e.source) else: src = e.source src = Path(jar_context, src) if '*' not in e.source and not os.path.exists(src.full_path): if e.is_locale: raise Exception( '%s: Cannot find %s' % (obj.path, e.source)) if e.source.startswith('/'): src = Path(jar_context, '!' + e.source) else: # This actually gets awkward if the jar.mn is not # in the same directory as the moz.build declaring # it, but it's how it works in the recursive make, # not that anything relies on that, but it's simpler. src = Path(obj._context, '!' + e.source) output_basename = mozpath.basename(e.output) if output_basename != src.target_basename: src = RenamedSourcePath(jar_context, (src, output_basename)) path = mozpath.dirname(mozpath.join(jarinfo.name, e.output)) if e.preprocess: if '*' in e.source: raise Exception('%s: Wildcards are not supported with ' 'preprocessing' % obj.path) files_pp[path] += [src] else: files[path] += [src] if files: self.consume_object(FinalTargetFiles(jar_context, files)) if files_pp: self.consume_object( FinalTargetPreprocessedFiles(jar_context, files_pp)) for m in jarinfo.chrome_manifests: entry = parse_manifest_line( mozpath.dirname(jarinfo.name), m.replace('%', mozpath.basename(jarinfo.name) + '/')) self.consume_object(ChromeManifestEntry( jar_context, '%s.manifest' % jarinfo.name, entry))