def _init(self):
CommonBackend._init(self)
self._backend_files = {}
self._ipdl_sources = set()
self._webidl_sources = set()
self._generated_events_webidl_sources = set()
self._test_webidl_sources = set()
self._preprocessed_test_webidl_sources = set()
self._preprocessed_webidl_sources = set()
self._generated_webidl_sources = set()
def detailed(summary):
s = '{:d} total backend files. {:d} created; {:d} updated; {:d} unchanged'.format(
summary.created_count + summary.updated_count +
summary.unchanged_count, summary.created_count,
summary.updated_count, summary.unchanged_count)
if summary.deleted_count:
s+= '; {:d} deleted'.format(summary.deleted_count)
return s
# This is a little kludgy and could be improved with a better API.
self.summary.backend_detailed_summary = types.MethodType(detailed,
self.summary)
self._test_manifests = {}
self.backend_input_files.add(os.path.join(self.environment.topobjdir,
'config', 'autoconf.mk'))
self._install_manifests = {
k: InstallManifest() for k in [
'dist_bin',
'dist_idl',
'dist_include',
'dist_public',
'dist_private',
'dist_sdk',
'tests',
'xpidl',
]}
self._traversal = RecursiveMakeTraversal()
self._may_skip = {
'export': set(),
'compile': set(),
'binaries': set(),
'libs': set(),
'tools': set(),
}
derecurse = self.environment.substs.get('MOZ_PSEUDO_DERECURSE', '').split(',')
self._parallel_export = False
self._no_skip = False
if derecurse != ['']:
self._parallel_export = 'no-parallel-export' not in derecurse
self._no_skip = 'no-skip' in derecurse
def test_test_manifests_duplicate_support_files(self):
"""Ensure duplicate support-files in test manifests work."""
env = self._consume('test-manifests-duplicate-support-files',
RecursiveMakeBackend)
p = os.path.join(env.topobjdir, '_build_manifests', 'install',
'_tests')
m = InstallManifest(p)
self.assertIn('testing/mochitest/tests/support-file.txt', m)
def test_test_support_files_tracked(self):
env = self._consume('test-support-binaries-tracked', RecursiveMakeBackend)
m = InstallManifest(path=mozpath.join(env.topobjdir,
'_build_manifests', 'install', '_tests'))
self.assertEqual(len(m), 4)
self.assertIn('xpcshell/tests/mozbuildtest/test-library.dll', m)
self.assertIn('xpcshell/tests/mozbuildtest/test-one.exe', m)
self.assertIn('xpcshell/tests/mozbuildtest/test-two.exe', m)
self.assertIn('xpcshell/tests/mozbuildtest/host-test-library.dll', m)
def process_manifest(destdir, paths, track,
no_symlinks=False,
defines={}):
if os.path.exists(track):
# We use the same format as install manifests for the tracking
# data.
manifest = InstallManifest(path=track)
remove_unaccounted = FileRegistry()
dummy_file = BaseFile()
finder = FileFinder(destdir, find_dotfiles=True)
for dest in manifest._dests:
for p, f in finder.find(dest):
remove_unaccounted.add(p, dummy_file)
remove_empty_directories=True
remove_all_directory_symlinks=True
else:
# If tracking is enabled and there is no file, we don't want to
# be removing anything.
remove_unaccounted = False
remove_empty_directories=False
remove_all_directory_symlinks=False
manifest = InstallManifest()
for path in paths:
manifest |= InstallManifest(path=path)
copier = FileCopier()
link_policy = "copy" if no_symlinks else "symlink"
manifest.populate_registry(
copier, defines_override=defines, link_policy=link_policy
)
result = copier.copy(destdir,
remove_unaccounted=remove_unaccounted,
remove_all_directory_symlinks=remove_all_directory_symlinks,
remove_empty_directories=remove_empty_directories)
if track:
manifest.write(path=track)
return result
def _get_test_manifest(self):
m = InstallManifest()
m.add_symlink(self.tmppath('s_source'), 's_dest')
m.add_copy(self.tmppath('c_source'), 'c_dest')
m.add_required_exists('e_dest')
m.add_optional_exists('o_dest')
m.add_pattern_symlink('ps_base', '*', 'ps_dest')
m.add_pattern_copy('pc_base', '**', 'pc_dest')
return m
def test_install_manifests_written(self):
env, objs = self._emit('stub0')
backend = RecursiveMakeBackend(env)
m = InstallManifest()
backend._install_manifests['testing'] = m
m.add_symlink(__file__, 'self')
backend.consume(objs)
man_dir = mozpath.join(env.topobjdir, '_build_manifests', 'install')
self.assertTrue(os.path.isdir(man_dir))
expected = ['testing']
for e in expected:
full = mozpath.join(man_dir, e)
self.assertTrue(os.path.exists(full))
m2 = InstallManifest(path=full)
self.assertEqual(m, m2)
def test_install_manifests_written(self):
env, objs = self._emit("stub0")
backend = RecursiveMakeBackend(env)
m = InstallManifest()
backend._install_manifests["testing"] = m
m.add_link(__file__, "self")
backend.consume(objs)
man_dir = mozpath.join(env.topobjdir, "_build_manifests", "install")
self.assertTrue(os.path.isdir(man_dir))
expected = ["testing"]
for e in expected:
full = mozpath.join(man_dir, e)
self.assertTrue(os.path.exists(full))
m2 = InstallManifest(path=full)
self.assertEqual(m, m2)
def consume_finished(self):
mp = os.path.join(self.environment.topobjdir, '_build_manifests',
'install', '_tests')
install_manifest = InstallManifest(mp)
reg = FileRegistry()
install_manifest.populate_registry(reg)
for dest, src in reg:
if not hasattr(src, 'path'):
continue
if not os.path.isabs(dest):
dest = '_tests/' + dest
obj_path = mozpath.join(self.environment.topobjdir, dest)
if isinstance(src, PreprocessedFile):
assert os.path.exists(obj_path), '%s should exist' % obj_path
pp_info = generate_pp_info(obj_path,
self.environment.topsrcdir)
else:
pp_info = None
rel_src = mozpath.relpath(src.path, self.environment.topsrcdir)
self._install_mapping[dest] = rel_src, pp_info
# Our result has four parts:
# A map from url prefixes to objdir directories:
# { "chrome://mozapps/content/": [ "dist/bin/chrome/toolkit/content/mozapps" ], ... }
# A map of overrides.
# A map from objdir paths to sourcedir paths, and an object storing mapping
# information for preprocessed files:
# { "dist/bin/browser/chrome/browser/content/browser/aboutSessionRestore.js":
# [ "$topsrcdir/browser/components/sessionstore/content/aboutSessionRestore.js", {} ],
# ... }
# An object containing build configuration information.
outputfile = os.path.join(self.environment.topobjdir,
'chrome-map.json')
with self._write_file(outputfile) as fh:
chrome_mapping = self.manifest_handler.chrome_mapping
overrides = self.manifest_handler.overrides
json.dump([{k: list(v)
for k, v in chrome_mapping.iteritems()}, overrides,
self._install_mapping, {
'topobjdir':
mozpath.normpath(self.environment.topobjdir),
'MOZ_APP_NAME':
self.environment.substs.get('MOZ_APP_NAME'),
'OMNIJAR_NAME':
self.environment.substs.get('OMNIJAR_NAME'),
'MOZ_MACBUNDLE_NAME':
self.environment.substs.get('MOZ_MACBUNDLE_NAME'),
}],
fh,
sort_keys=True,
indent=2)
def test_process_manifest(self):
source = self.tmppath('source')
os.mkdir(source)
os.mkdir('%s/base' % source)
os.mkdir('%s/base/foo' % source)
os.mkdir('%s/base2' % source)
with open('%s/base/foo/file1' % source, 'a'):
pass
with open('%s/base/foo/file2' % source, 'a'):
pass
with open('%s/base2/file3' % source, 'a'):
pass
m = InstallManifest()
m.add_pattern_link('%s/base' % source, '**', '')
m.add_link('%s/base2/file3' % source, 'foo/file3')
p = self.tmppath('m')
m.write(path=p)
dest = self.tmppath('dest')
track = self.tmppath('track')
for i in range(2):
process_install_manifest.process_manifest(dest, [p], track)
self.assertTrue(os.path.exists(self.tmppath('dest/foo/file1')))
self.assertTrue(os.path.exists(self.tmppath('dest/foo/file2')))
self.assertTrue(os.path.exists(self.tmppath('dest/foo/file3')))
m = InstallManifest()
m.write(path=p)
for i in range(2):
process_install_manifest.process_manifest(dest, [p], track)
self.assertFalse(os.path.exists(self.tmppath('dest/foo/file1')))
self.assertFalse(os.path.exists(self.tmppath('dest/foo/file2')))
self.assertFalse(os.path.exists(self.tmppath('dest/foo/file3')))
def test_process_manifest(self):
source = self.tmppath("source")
os.mkdir(source)
os.mkdir("%s/base" % source)
os.mkdir("%s/base/foo" % source)
os.mkdir("%s/base2" % source)
with open("%s/base/foo/file1" % source, "a"):
pass
with open("%s/base/foo/file2" % source, "a"):
pass
with open("%s/base2/file3" % source, "a"):
pass
m = InstallManifest()
m.add_pattern_link("%s/base" % source, "**", "")
m.add_link("%s/base2/file3" % source, "foo/file3")
p = self.tmppath("m")
m.write(path=p)
dest = self.tmppath("dest")
track = self.tmppath("track")
for i in range(2):
process_install_manifest.process_manifest(dest, [p], track)
self.assertTrue(os.path.exists(self.tmppath("dest/foo/file1")))
self.assertTrue(os.path.exists(self.tmppath("dest/foo/file2")))
self.assertTrue(os.path.exists(self.tmppath("dest/foo/file3")))
m = InstallManifest()
m.write(path=p)
for i in range(2):
process_install_manifest.process_manifest(dest, [p], track)
self.assertFalse(os.path.exists(self.tmppath("dest/foo/file1")))
self.assertFalse(os.path.exists(self.tmppath("dest/foo/file2")))
self.assertFalse(os.path.exists(self.tmppath("dest/foo/file3")))
def test_branding_files(self):
"""Ensure BRANDING_FILES is handled properly."""
env = self._consume('branding-files', RecursiveMakeBackend)
#BRANDING_FILES should appear in the dist_branding install manifest.
m = InstallManifest(path=os.path.join(
env.topobjdir, '_build_manifests', 'install', 'dist_branding'))
self.assertEqual(len(m), 3)
self.assertIn('bar.ico', m)
self.assertIn('quux.png', m)
self.assertIn('icons/foo.ico', m)
def test_exports(self):
"""Ensure EXPORTS is handled properly."""
env = self._consume('exports', RecursiveMakeBackend)
# EXPORTS files should appear in the dist_include install manifest.
m = InstallManifest(path=mozpath.join(
env.topobjdir, '_build_manifests', 'install', 'dist_include'))
self.assertEqual(len(m), 7)
self.assertIn('foo.h', m)
self.assertIn('mozilla/mozilla1.h', m)
self.assertIn('mozilla/dom/dom2.h', m)
def test_test_manifest_pattern_matches_recorded(self):
"""Pattern matches in test manifests' support-files should be recorded."""
env = self._consume('test-manifests-written', RecursiveMakeBackend)
m = InstallManifest(path=mozpath.join(
env.topobjdir, '_build_manifests', 'install', 'tests'))
# This is not the most robust test in the world, but it gets the job
# done.
entries = [e for e in m._dests.keys() if '**' in e]
self.assertEqual(len(entries), 1)
self.assertIn('support/**', entries[0])
def _load_manifest(self, path, root):
install_manifest = InstallManifest(path)
reg = FileRegistry()
install_manifest.populate_registry(reg)
for dest, src in reg:
if hasattr(src, 'path'):
if not os.path.isabs(dest):
dest = root + dest
self._install_mapping[dest] = (src.path,
isinstance(
src, PreprocessedFile))
def _get_test_manifest(self):
m = InstallManifest()
m.add_link(self.tmppath('s_source'), 's_dest')
m.add_copy(self.tmppath('c_source'), 'c_dest')
m.add_preprocess(self.tmppath('p_source'), 'p_dest', self.tmppath('p_source.pp'), '#', {'FOO':'BAR', 'BAZ':'QUX'})
m.add_required_exists('e_dest')
m.add_optional_exists('o_dest')
m.add_pattern_link('ps_base', '*', 'ps_dest')
m.add_pattern_copy('pc_base', '**', 'pc_dest')
m.add_content('the content\non\nmultiple lines', 'content')
return m
def test_final_target_files_wildcard(self):
"""Ensure that wildcards in FINAL_TARGET_FILES work properly."""
env = self._consume("final-target-files-wildcard", FasterMakeBackend)
m = InstallManifest(
path=mozpath.join(env.topobjdir, "faster", "install_dist_bin"))
self.assertEqual(len(m), 1)
reg = FileRegistry()
m.populate_registry(reg)
expected = [("foo/bar.xyz", "bar.xyz"), ("foo/foo.xyz", "foo.xyz")]
actual = [(path, mozpath.relpath(f.path, env.topsrcdir))
for (path, f) in reg]
self.assertEqual(expected, actual)
def test_write_expand_pattern(self):
source = self.tmppath('source')
os.mkdir(source)
os.mkdir('%s/base' % source)
os.mkdir('%s/base/foo' % source)
with open('%s/base/foo/file1' % source, 'a'):
pass
with open('%s/base/foo/file2' % source, 'a'):
pass
m = InstallManifest()
m.add_pattern_link('%s/base' % source, '**', 'dest')
track = self.tmppath('track')
m.write(path=track, expand_pattern=True)
m = InstallManifest(path=track)
self.assertEqual([dest for dest in m._dests],
['dest/foo/file1', 'dest/foo/file2'])
def test_write_expand_pattern(self):
source = self.tmppath("source")
os.mkdir(source)
os.mkdir("%s/base" % source)
os.mkdir("%s/base/foo" % source)
with open("%s/base/foo/file1" % source, "a"):
pass
with open("%s/base/foo/file2" % source, "a"):
pass
m = InstallManifest()
m.add_pattern_link("%s/base" % source, "**", "dest")
track = self.tmppath("track")
m.write(path=track, expand_pattern=True)
m = InstallManifest(path=track)
self.assertEqual(sorted(dest for dest in m._dests),
["dest/foo/file1", "dest/foo/file2"])
def install_test_files(topsrcdir, topobjdir, tests_root):
"""Installs the requested test files to the objdir. This is invoked by
test runners to avoid installing tens of thousands of test files when
only a few tests need to be run.
"""
manifest = InstallManifest(
mozpath.join(topobjdir, '_build_manifests', 'install', '_test_files'))
harness_files_manifest = mozpath.join(topobjdir, '_build_manifests',
'install', tests_root)
if os.path.isfile(harness_files_manifest):
# If the backend has generated an install manifest for test harness
# files they are treated as a monolith and installed each time we
# run tests. Fortunately there are not very many.
manifest |= InstallManifest(harness_files_manifest)
copier = FileCopier()
manifest.populate_registry(copier)
copier.copy(mozpath.join(topobjdir, tests_root), remove_unaccounted=False)
def test_test_manifest_deffered_installs_written(self):
"""Shared support files are written to their own data file by the backend."""
env = self._consume("test-manifest-shared-support",
RecursiveMakeBackend)
# First, read the generated for ini manifest contents.
test_files_manifest = mozpath.join(env.topobjdir, "_build_manifests",
"install", "_test_files")
m = InstallManifest(path=test_files_manifest)
# Then, synthesize one from the test-installs.pkl file. This should
# allow us to re-create a subset of the above.
env = self._consume("test-manifest-shared-support",
TestManifestBackend)
test_installs_path = mozpath.join(env.topobjdir, "test-installs.pkl")
with open(test_installs_path, "rb") as fh:
test_installs = pickle.load(fh)
self.assertEqual(
set(test_installs.keys()),
set([
"child/test_sub.js", "child/data/**", "child/another-file.sjs"
]),
)
for key in test_installs.keys():
self.assertIn(key, test_installs)
synthesized_manifest = InstallManifest()
for item, installs in test_installs.items():
for install_info in installs:
if len(install_info) == 3:
synthesized_manifest.add_pattern_link(*install_info)
if len(install_info) == 2:
synthesized_manifest.add_link(*install_info)
self.assertEqual(len(synthesized_manifest), 3)
for item, info in synthesized_manifest._dests.items():
self.assertIn(item, m)
self.assertEqual(info, m._dests[item])
def test_xpidl_generation(self):
"""Ensure xpidl files and directories are written out."""
env = self._consume("xpidl", RecursiveMakeBackend)
# Install manifests should contain entries.
install_dir = mozpath.join(env.topobjdir, "_build_manifests",
"install")
self.assertTrue(os.path.isfile(mozpath.join(install_dir, "xpidl")))
m = InstallManifest(path=mozpath.join(install_dir, "xpidl"))
self.assertIn(".deps/my_module.pp", m)
m = InstallManifest(path=mozpath.join(install_dir, "xpidl"))
self.assertIn("my_module.xpt", m)
m = InstallManifest(path=mozpath.join(install_dir, "dist_include"))
self.assertIn("foo.h", m)
p = mozpath.join(env.topobjdir, "config/makefiles/xpidl")
self.assertTrue(os.path.isdir(p))
self.assertTrue(os.path.isfile(mozpath.join(p, "Makefile")))
def test_xpidl_generation(self):
"""Ensure xpidl files and directories are written out."""
env = self._consume('xpidl', RecursiveMakeBackend)
# Install manifests should contain entries.
install_dir = mozpath.join(env.topobjdir, '_build_manifests',
'install')
self.assertTrue(os.path.isfile(mozpath.join(install_dir, 'xpidl')))
m = InstallManifest(path=mozpath.join(install_dir, 'xpidl'))
self.assertIn('.deps/my_module.pp', m)
m = InstallManifest(path=mozpath.join(install_dir, 'xpidl'))
self.assertIn('my_module.xpt', m)
m = InstallManifest(path=mozpath.join(install_dir, 'dist_include'))
self.assertIn('foo.h', m)
p = mozpath.join(env.topobjdir, 'config/makefiles/xpidl')
self.assertTrue(os.path.isdir(p))
self.assertTrue(os.path.isfile(mozpath.join(p, 'Makefile')))
def test_test_manifest_deffered_installs_written(self):
"""Shared support files are written to their own data file by the backend."""
env = self._consume('test-manifest-shared-support',
RecursiveMakeBackend)
all_tests_path = mozpath.join(env.topobjdir, 'all-tests.pkl')
self.assertTrue(os.path.exists(all_tests_path))
test_installs_path = mozpath.join(env.topobjdir, 'test-installs.pkl')
with open(test_installs_path, 'r') as fh:
test_installs = pickle.load(fh)
self.assertEqual(
set(test_installs.keys()),
set([
'child/test_sub.js', 'child/data/**', 'child/another-file.sjs'
]))
for key in test_installs.keys():
self.assertIn(key, test_installs)
test_files_manifest = mozpath.join(env.topobjdir, '_build_manifests',
'install', '_test_files')
# First, read the generated for ini manifest contents.
m = InstallManifest(path=test_files_manifest)
# Then, synthesize one from the test-installs.pkl file. This should
# allow us to re-create a subset of the above.
synthesized_manifest = InstallManifest()
for item, installs in test_installs.items():
for install_info in installs:
if len(install_info) == 3:
synthesized_manifest.add_pattern_symlink(*install_info)
if len(install_info) == 2:
synthesized_manifest.add_symlink(*install_info)
self.assertEqual(len(synthesized_manifest), 3)
for item, info in synthesized_manifest._dests.items():
self.assertIn(item, m)
self.assertEqual(info, m._dests[item])
def test_old_install_manifest_deleted(self):
# Simulate an install manifest from a previous backend version. Ensure
# it is deleted.
env = self._get_environment('stub0')
purge_dir = mozpath.join(env.topobjdir, '_build_manifests', 'install')
manifest_path = mozpath.join(purge_dir, 'old_manifest')
os.makedirs(purge_dir)
m = InstallManifest()
m.write(path=manifest_path)
self.assertTrue(os.path.exists(manifest_path))
self._consume('stub0', RecursiveMakeBackend, env)
self.assertFalse(os.path.exists(manifest_path))
def file_copier(self):
# TODO: invalidate the file copier when the build system
# itself changes, i.e., the underlying unified manifest
# changes.
file_copier = FileCopier()
unified_manifest = InstallManifest(
mozpath.join(self.config_environment.topobjdir,
'faster', 'unified_install_dist_bin'))
unified_manifest.populate_registry(file_copier, defines_override=self.defines)
return file_copier
def test_or(self):
m1 = self._get_test_manifest()
m2 = InstallManifest()
m2.add_symlink('s_source2', 's_dest2')
m2.add_copy('c_source2', 'c_dest2')
m1 |= m2
self.assertEqual(len(m2), 2)
self.assertEqual(len(m1), 6)
self.assertIn('s_dest2', m1)
self.assertIn('c_dest2', m1)
def _init(self):
CommonBackend._init(self)
self._backend_files = {}
self._ipdl_sources = set()
self._webidl_sources = set()
self._generated_events_webidl_sources = set()
self._test_webidl_sources = set()
self._preprocessed_webidl_sources = set()
self._generated_webidl_sources = set()
def detailed(summary):
return '{:d} total backend files. {:d} created; {:d} updated; {:d} unchanged'.format(
summary.managed_count, summary.created_count,
summary.updated_count, summary.unchanged_count)
# This is a little kludgy and could be improved with a better API.
self.summary.backend_detailed_summary = types.MethodType(
detailed, self.summary)
self.xpcshell_manifests = []
self.backend_input_files.add(
os.path.join(self.environment.topobjdir, 'config', 'autoconf.mk'))
self._purge_manifests = dict(
dist_bin=PurgeManifest(relpath='dist/bin'),
dist_private=PurgeManifest(relpath='dist/private'),
dist_public=PurgeManifest(relpath='dist/public'),
dist_sdk=PurgeManifest(relpath='dist/sdk'),
tests=PurgeManifest(relpath='_tests'),
xpidl=PurgeManifest(relpath='config/makefiles/xpidl'),
)
self._install_manifests = dict(
dist_idl=InstallManifest(),
dist_include=InstallManifest(),
)
def test_or(self):
m1 = self._get_test_manifest()
orig_length = len(m1)
m2 = InstallManifest()
m2.add_link("s_source2", "s_dest2")
m2.add_copy("c_source2", "c_dest2")
m1 |= m2
self.assertEqual(len(m2), 2)
self.assertEqual(len(m1), orig_length + 2)
self.assertIn("s_dest2", m1)
self.assertIn("c_dest2", m1)
def test_exports_generated(self):
"""Ensure EXPORTS that are listed in GENERATED_FILES
are handled properly."""
env = self._consume('exports-generated', RecursiveMakeBackend)
# EXPORTS files should appear in the dist_include install manifest.
m = InstallManifest(path=mozpath.join(
env.topobjdir, '_build_manifests', 'install', 'dist_include'))
self.assertEqual(len(m), 8)
self.assertIn('foo.h', m)
self.assertIn('mozilla/mozilla1.h', m)
self.assertIn('mozilla/dom/dom1.h', m)
self.assertIn('gfx/gfx.h', m)
self.assertIn('bar.h', m)
self.assertIn('mozilla/mozilla2.h', m)
self.assertIn('mozilla/dom/dom2.h', m)
self.assertIn('mozilla/dom/dom3.h', m)
# EXPORTS files that are also GENERATED_FILES should be handled as
# INSTALL_TARGETS.
backend_path = mozpath.join(env.topobjdir, 'backend.mk')
lines = [l.strip() for l in open(backend_path, 'rt').readlines()[2:]]
expected = [
'export:: bar.h',
'GARBAGE += bar.h',
'EXTRA_MDDEPEND_FILES += bar.h.pp',
'export:: mozilla2.h',
'GARBAGE += mozilla2.h',
'EXTRA_MDDEPEND_FILES += mozilla2.h.pp',
'export:: dom2.h',
'GARBAGE += dom2.h',
'EXTRA_MDDEPEND_FILES += dom2.h.pp',
'export:: dom3.h',
'GARBAGE += dom3.h',
'EXTRA_MDDEPEND_FILES += dom3.h.pp',
'dist_include_FILES += bar.h',
'dist_include_DEST := $(DEPTH)/dist/include/',
'dist_include_TARGET := export',
'INSTALL_TARGETS += dist_include',
'dist_include_mozilla_FILES += mozilla2.h',
'dist_include_mozilla_DEST := $(DEPTH)/dist/include/mozilla',
'dist_include_mozilla_TARGET := export',
'INSTALL_TARGETS += dist_include_mozilla',
'dist_include_mozilla_dom_FILES += dom2.h',
'dist_include_mozilla_dom_FILES += dom3.h',
'dist_include_mozilla_dom_DEST := $(DEPTH)/dist/include/mozilla/dom',
'dist_include_mozilla_dom_TARGET := export',
'INSTALL_TARGETS += dist_include_mozilla_dom',
]
self.maxDiff = None
self.assertEqual(lines, expected)
def find_generated_harness_files():
# TEST_HARNESS_FILES end up in an install manifest at
# $topsrcdir/_build_manifests/install/_tests.
manifest = InstallManifest(mozpath.join(buildconfig.topobjdir,
'_build_manifests',
'install',
'_tests'))
registry = FileRegistry()
manifest.populate_registry(registry)
# Conveniently, the generated files we care about will already
# exist in the objdir, so we can identify relevant files if
# they're an `ExistingFile` instance.
return [mozpath.join('_tests', p) for p in registry.paths()
if isinstance(registry[p], ExistingFile)]
