def test_replace_symlink(self):
'''
Test that if the destination exists, and is a symlink, the target of
the symlink is not overwritten by the preprocessor output.
'''
if not self.symlink_supported:
return
source = self.tmppath('source')
dest = self.tmppath('dest')
pp_source = self.tmppath('pp_in')
deps = self.tmppath('deps')
with open(source, 'a'):
pass
os.symlink(source, dest)
self.assertTrue(os.path.islink(dest))
with open(pp_source, 'wb') as tmp:
tmp.write('#define FOO\nPREPROCESSED')
f = PreprocessedFile(pp_source,
depfile_path=deps,
marker='#',
defines={'FOO': True})
self.assertTrue(f.copy(dest))
self.assertEqual('PREPROCESSED', open(dest, 'rb').read())
self.assertFalse(os.path.islink(dest))
self.assertEqual('', open(source, 'rb').read())
def test_replace_symlink(self):
"""
Test that if the destination exists, and is a symlink, the target of
the symlink is not overwritten by the preprocessor output.
"""
if not self.symlink_supported:
return
source = self.tmppath("source")
dest = self.tmppath("dest")
pp_source = self.tmppath("pp_in")
deps = self.tmppath("deps")
with open(source, "a"):
pass
os.symlink(source, dest)
self.assertTrue(os.path.islink(dest))
with open(pp_source, "wb") as tmp:
tmp.write(b"#define FOO\nPREPROCESSED")
f = PreprocessedFile(pp_source,
depfile_path=deps,
marker="#",
defines={"FOO": True})
self.assertTrue(f.copy(dest))
self.assertEqual(b"PREPROCESSED", open(dest, "rb").read())
self.assertFalse(os.path.islink(dest))
self.assertEqual(b"", open(source, "rb").read())
def test_replace_symlink(self):
'''
Test that if the destination exists, and is a symlink, the target of
the symlink is not overwritten by the preprocessor output.
'''
if not self.symlink_supported:
return
source = self.tmppath('source')
dest = self.tmppath('dest')
pp_source = self.tmppath('pp_in')
deps = self.tmppath('deps')
with open(source, 'a'):
pass
os.symlink(source, dest)
self.assertTrue(os.path.islink(dest))
with open(pp_source, 'wb') as tmp:
tmp.write('#define FOO\nPREPROCESSED')
f = PreprocessedFile(pp_source, depfile_path=deps, marker='#',
defines={'FOO': True})
self.assertTrue(f.copy(dest))
self.assertEqual('PREPROCESSED', open(dest, 'rb').read())
self.assertFalse(os.path.islink(dest))
self.assertEqual('', open(source, 'rb').read())
def test_preprocess_file_no_write(self):
'''
Test various conditions where PreprocessedFile.copy is expected not to
write in the destination file.
'''
src = self.tmppath('src')
dest = self.tmppath('dest')
depfile = self.tmppath('depfile')
with open(src, 'wb') as tmp:
tmp.write('#ifdef FOO\ntest\n#endif')
# Initial copy
f = PreprocessedFile(src, depfile_path=depfile, marker='#', defines={'FOO': True})
self.assertTrue(f.copy(dest))
# Ensure subsequent copies won't trigger writes
self.assertFalse(f.copy(DestNoWrite(dest)))
self.assertEqual('test\n', open(dest, 'rb').read())
# When the source file is older than the destination file, even with
# different content, no copy should occur.
with open(src, 'wb') as tmp:
tmp.write('#ifdef FOO\nfooo\n#endif')
time = os.path.getmtime(dest) - 1
os.utime(src, (time, time))
self.assertFalse(f.copy(DestNoWrite(dest)))
self.assertEqual('test\n', open(dest, 'rb').read())
# skip_if_older=False is expected to force a copy in this situation.
self.assertTrue(f.copy(dest, skip_if_older=False))
self.assertEqual('fooo\n', open(dest, 'rb').read())
def test_preprocess(self):
'''
Test that copying the file invokes the preprocessor
'''
src = self.tmppath('src')
dest = self.tmppath('dest')
with open(src, 'wb') as tmp:
tmp.write('#ifdef FOO\ntest\n#endif')
f = PreprocessedFile(src, depfile_path=None, marker='#', defines={'FOO': True})
self.assertTrue(f.copy(dest))
self.assertEqual('test\n', open(dest, 'rb').read())
def test_preprocess(self):
'''
Test that copying the file invokes the preprocessor
'''
src = self.tmppath('src')
dest = self.tmppath('dest')
with open(src, 'wb') as tmp:
tmp.write('#ifdef FOO\ntest\n#endif')
f = PreprocessedFile(src, depfile_path=None, marker='#', defines={'FOO': True})
self.assertTrue(f.copy(dest))
self.assertEqual('test\n', open(dest, 'rb').read())
def test_preprocess(self):
"""
Test that copying the file invokes the preprocessor
"""
src = self.tmppath("src")
dest = self.tmppath("dest")
with open(src, "wb") as tmp:
tmp.write(b"#ifdef FOO\ntest\n#endif")
f = PreprocessedFile(src, depfile_path=None, marker="#", defines={"FOO": True})
self.assertTrue(f.copy(dest))
self.assertEqual(b"test\n", open(dest, "rb").read())
def test_preprocess_file_dependencies(self):
'''
Test that the preprocess runs if the dependencies of the source change
'''
src = self.tmppath('src')
dest = self.tmppath('dest')
incl = self.tmppath('incl')
deps = self.tmppath('src.pp')
with open(src, 'wb') as tmp:
tmp.write('#ifdef FOO\ntest\n#endif')
with open(incl, 'wb') as tmp:
tmp.write('foo bar')
# Initial copy
f = PreprocessedFile(src, depfile_path=deps, marker='#', defines={'FOO': True})
self.assertTrue(f.copy(dest))
# Update the source so it #includes the include file.
with open(src, 'wb') as tmp:
tmp.write('#include incl\n')
time = os.path.getmtime(dest) + 1
os.utime(src, (time, time))
self.assertTrue(f.copy(dest))
self.assertEqual('foo bar', open(dest, 'rb').read())
# If one of the dependencies changes, the file should be updated. The
# mtime of the dependency is set after the destination file, to avoid
# both files having the same time.
with open(incl, 'wb') as tmp:
tmp.write('quux')
time = os.path.getmtime(dest) + 1
os.utime(incl, (time, time))
self.assertTrue(f.copy(dest))
self.assertEqual('quux', open(dest, 'rb').read())
# Perform one final copy to confirm that we don't run the preprocessor
# again. We update the mtime of the destination so it's newer than the
# input files. This would "just work" if we weren't changing
time = os.path.getmtime(incl) + 1
os.utime(dest, (time, time))
self.assertFalse(f.copy(DestNoWrite(dest)))
def test_preprocess_file_no_write(self):
"""
Test various conditions where PreprocessedFile.copy is expected not to
write in the destination file.
"""
src = self.tmppath("src")
dest = self.tmppath("dest")
depfile = self.tmppath("depfile")
with open(src, "wb") as tmp:
tmp.write(b"#ifdef FOO\ntest\n#endif")
# Initial copy
f = PreprocessedFile(src,
depfile_path=depfile,
marker="#",
defines={"FOO": True})
self.assertTrue(f.copy(dest))
# Ensure subsequent copies won't trigger writes
self.assertFalse(f.copy(DestNoWrite(dest)))
self.assertEqual(b"test\n", open(dest, "rb").read())
# When the source file is older than the destination file, even with
# different content, no copy should occur.
with open(src, "wb") as tmp:
tmp.write(b"#ifdef FOO\nfooo\n#endif")
time = os.path.getmtime(dest) - 1
os.utime(src, (time, time))
self.assertFalse(f.copy(DestNoWrite(dest)))
self.assertEqual(b"test\n", open(dest, "rb").read())
# skip_if_older=False is expected to force a copy in this situation.
self.assertTrue(f.copy(dest, skip_if_older=False))
self.assertEqual(b"fooo\n", open(dest, "rb").read())
def test_preprocess_file_no_write(self):
'''
Test various conditions where PreprocessedFile.copy is expected not to
write in the destination file.
'''
src = self.tmppath('src')
dest = self.tmppath('dest')
depfile = self.tmppath('depfile')
with open(src, 'wb') as tmp:
tmp.write('#ifdef FOO\ntest\n#endif')
# Initial copy
f = PreprocessedFile(src,
depfile_path=depfile,
marker='#',
defines={'FOO': True})
self.assertTrue(f.copy(dest))
# Ensure subsequent copies won't trigger writes
self.assertFalse(f.copy(DestNoWrite(dest)))
self.assertEqual('test\n', open(dest, 'rb').read())
# When the source file is older than the destination file, even with
# different content, no copy should occur.
with open(src, 'wb') as tmp:
tmp.write('#ifdef FOO\nfooo\n#endif')
time = os.path.getmtime(dest) - 1
os.utime(src, (time, time))
self.assertFalse(f.copy(DestNoWrite(dest)))
self.assertEqual('test\n', open(dest, 'rb').read())
# skip_if_older=False is expected to force a copy in this situation.
self.assertTrue(f.copy(dest, skip_if_older=False))
self.assertEqual('fooo\n', open(dest, 'rb').read())
def test_preprocess_file_dependencies(self):
"""
Test that the preprocess runs if the dependencies of the source change
"""
src = self.tmppath("src")
dest = self.tmppath("dest")
incl = self.tmppath("incl")
deps = self.tmppath("src.pp")
with open(src, "wb") as tmp:
tmp.write(b"#ifdef FOO\ntest\n#endif")
with open(incl, "wb") as tmp:
tmp.write(b"foo bar")
# Initial copy
f = PreprocessedFile(src,
depfile_path=deps,
marker="#",
defines={"FOO": True})
self.assertTrue(f.copy(dest))
# Update the source so it #includes the include file.
with open(src, "wb") as tmp:
tmp.write(b"#include incl\n")
time = os.path.getmtime(dest) + 1
os.utime(src, (time, time))
self.assertTrue(f.copy(dest))
self.assertEqual(b"foo bar", open(dest, "rb").read())
# If one of the dependencies changes, the file should be updated. The
# mtime of the dependency is set after the destination file, to avoid
# both files having the same time.
with open(incl, "wb") as tmp:
tmp.write(b"quux")
time = os.path.getmtime(dest) + 1
os.utime(incl, (time, time))
self.assertTrue(f.copy(dest))
self.assertEqual(b"quux", open(dest, "rb").read())
# Perform one final copy to confirm that we don't run the preprocessor
# again. We update the mtime of the destination so it's newer than the
# input files. This would "just work" if we weren't changing
time = os.path.getmtime(incl) + 1
os.utime(dest, (time, time))
self.assertFalse(f.copy(DestNoWrite(dest)))
def test_preprocess_file_dependencies(self):
'''
Test that the preprocess runs if the dependencies of the source change
'''
src = self.tmppath('src')
dest = self.tmppath('dest')
incl = self.tmppath('incl')
deps = self.tmppath('src.pp')
with open(src, 'wb') as tmp:
tmp.write('#ifdef FOO\ntest\n#endif')
with open(incl, 'wb') as tmp:
tmp.write('foo bar')
# Initial copy
f = PreprocessedFile(src,
depfile_path=deps,
marker='#',
defines={'FOO': True})
self.assertTrue(f.copy(dest))
# Update the source so it #includes the include file.
with open(src, 'wb') as tmp:
tmp.write('#include incl\n')
time = os.path.getmtime(dest) + 1
os.utime(src, (time, time))
self.assertTrue(f.copy(dest))
self.assertEqual('foo bar', open(dest, 'rb').read())
# If one of the dependencies changes, the file should be updated. The
# mtime of the dependency is set after the destination file, to avoid
# both files having the same time.
with open(incl, 'wb') as tmp:
tmp.write('quux')
time = os.path.getmtime(dest) + 1
os.utime(incl, (time, time))
self.assertTrue(f.copy(dest))
self.assertEqual('quux', open(dest, 'rb').read())
# Perform one final copy to confirm that we don't run the preprocessor
# again. We update the mtime of the destination so it's newer than the
# input files. This would "just work" if we weren't changing
time = os.path.getmtime(incl) + 1
os.utime(dest, (time, time))
self.assertFalse(f.copy(DestNoWrite(dest)))
def _process_android_eclipse_project_data(self, data, srcdir, objdir):
# This can't be relative to the environment's topsrcdir,
# because during testing topsrcdir is faked.
template_directory = os.path.abspath(
mozpath.join(os.path.dirname(__file__), 'templates',
'android_eclipse'))
project_directory = mozpath.join(self.environment.topobjdir,
'android_eclipse', data.name)
manifest_path = mozpath.join(self.environment.topobjdir,
'android_eclipse',
'%s.manifest' % data.name)
manifest = self._manifest_for_project(srcdir, data)
ensureParentDir(manifest_path)
manifest.write(path=manifest_path)
classpathentries = []
for cpe in sorted(data._classpathentries, key=lambda x: x.path):
e = self._Element_for_classpathentry(cpe)
classpathentries.append(ET.tostring(e))
for name in sorted(data.referenced_projects):
e = self._Element_for_referenced_project(name)
classpathentries.append(ET.tostring(e))
for name in sorted(data.extra_jars):
e = self._Element_for_extra_jar(mozpath.join(srcdir, name))
classpathentries.append(ET.tostring(e))
defines = {}
defines['IDE_OBJDIR'] = objdir
defines['IDE_TOPOBJDIR'] = self.environment.topobjdir
defines['IDE_SRCDIR'] = srcdir
defines['IDE_TOPSRCDIR'] = self.environment.topsrcdir
defines['IDE_PROJECT_NAME'] = data.name
defines['IDE_PACKAGE_NAME'] = data.package_name
defines['IDE_PROJECT_DIRECTORY'] = project_directory
defines['IDE_RELSRCDIR'] = mozpath.relpath(srcdir,
self.environment.topsrcdir)
defines['IDE_CLASSPATH_ENTRIES'] = '\n'.join(
'\t' + cpe for cpe in classpathentries)
defines['IDE_RECURSIVE_MAKE_TARGETS'] = ' '.join(
sorted(data.recursive_make_targets))
# Like android.library=true
defines[
'IDE_PROJECT_LIBRARY_SETTING'] = 'android.library=true' if data.is_library else ''
# Like android.library.reference.1=FennecBrandingResources
defines['IDE_PROJECT_LIBRARY_REFERENCES'] = '\n'.join(
'android.library.reference.%s=%s' % (i + 1, ref)
for i, ref in enumerate(sorted(data.included_projects)))
if data.filtered_resources:
filteredResources = self._Element_for_filtered_resources(
data.filtered_resources)
defines['IDE_PROJECT_FILTERED_RESOURCES'] = pretty_print(
filteredResources).strip()
else:
defines['IDE_PROJECT_FILTERED_RESOURCES'] = ''
defines['ANDROID_TARGET_SDK'] = self.environment.substs[
'ANDROID_TARGET_SDK']
defines['MOZ_ANDROID_MIN_SDK_VERSION'] = self.environment.defines[
'MOZ_ANDROID_MIN_SDK_VERSION']
copier = FileCopier()
finder = FileFinder(template_directory)
for input_filename, f in itertools.chain(finder.find('**'),
finder.find('.**')):
if input_filename == 'AndroidManifest.xml' and not data.is_library:
# Main projects supply their own manifests.
continue
copier.add(
input_filename,
PreprocessedFile(
mozpath.join(finder.base, input_filename),
depfile_path=None,
marker='#',
defines=defines,
extra_depends={mozpath.join(finder.base, input_filename)}))
# When we re-create the build backend, we kill everything that was there.
if os.path.isdir(project_directory):
self._updated_count += 1
else:
self._created_count += 1
copier.copy(project_directory,
skip_if_older=False,
remove_unaccounted=True)
