def handle_line(self, str):
     f = str.strip()
     if not f:
         return
     if self.copier.contains(f):
         errors.error('Removal of packaged file(s): %s' % f)
     self.content += f + '\n'

 def test_error_loop(self):
     with self.assertRaises(AccumulatedErrors):
         with errors.accumulate():
             for i in range(3):
                 errors.error('%d' % i)
     self.assertEquals(self.get_output(),
                       ['Error: 0', 'Error: 1', 'Error: 2'])

 def _find(self, path):
     '''
     UnifiedFinder.find() implementation.
     '''
     files1 = OrderedDict()
     for p, f in self._finder1.find(path):
         files1[p] = f
     files2 = set()
     for p, f in self._finder2.find(path):
         files2.add(p)
         if p in files1:
             if may_unify_binary(files1[p]) and \
                     may_unify_binary(f):
                 yield p, UnifiedExecutableFile(files1[p], f)
             else:
                 err = errors.count
                 unified = self.unify_file(p, files1[p], f)
                 if unified:
                     yield p, unified
                 elif err == errors.count:
                     self._report_difference(p, files1[p], f)
         else:
             errors.error('File missing in %s: %s' %
                          (self._finder1.base, p))
     for p in [p for p in files1 if not p in files2]:
         errors.error('File missing in %s: %s' % (self._finder2.base, p))

 def add(self, section, pattern):
     '''
     Add files with the given pattern.
     '''
     assert not self._closed
     added = False
     for p, f in self._finder.find(pattern):
         added = True
         if is_manifest(p):
             self._manifests.add(p)
         self.packager.add(SimpleManifestSink.normalize_path(p), f)
     if not added:
         errors.error('Missing file(s): %s' % pattern)

 def add(self, path, content):
     """
     Add a BaseFile instance to the container, under the given path.
     """
     assert isinstance(content, BaseFile)
     if path in self._files:
         return errors.error("%s already added" % path)
     # Check whether any parent of the given path is already stored
     partial_path = path
     while partial_path:
         partial_path = mozpack.path.dirname(partial_path)
         if partial_path in self._files:
             return errors.error("Can't add %s: %s is a file" % (path, partial_path))
     self._files[path] = content

 def add(self, component, pattern):
     '''
     Add files with the given pattern in the given component.
     '''
     assert not self._closed
     added = False
     for p, f in self._finder.find(pattern):
         added = True
         if is_manifest(p):
             self._manifests.add(p)
         dest = mozpath.join(component.destdir, SimpleManifestSink.normalize_path(p))
         self.packager.add(dest, f)
     if not added:
         errors.error('Missing file(s): %s' % pattern)

 def _report_difference(self, path, file1, file2):
     '''
     Report differences between files in both trees.
     '''
     errors.error("Can't unify %s: file differs between %s and %s" %
                  (path, self._finder1.base, self._finder2.base))
     if not isinstance(file1, ExecutableFile) and \
             not isinstance(file2, ExecutableFile):
         from difflib import unified_diff
         for line in unified_diff(file1.open().readlines(),
                                  file2.open().readlines(),
                                  os.path.join(self._finder1.base, path),
                                  os.path.join(self._finder2.base, path)):
             errors.out.write(line)

 def add(self, path, content):
     '''
     Add a BaseFile instance to the container, under the given path.
     '''
     assert isinstance(content, BaseFile)
     if path in self._files:
         return errors.error("%s already added" % path)
     if self._required_directories[path] > 0:
         return errors.error("Can't add %s: it is a required directory" %
                             path)
     # Check whether any parent of the given path is already stored
     partial_paths = self._partial_paths(path)
     for partial_path in partial_paths:
         if partial_path in self._files:
             return errors.error("Can't add %s: %s is a file" %
                                 (path, partial_path))
     self._files[path] = content
     self._required_directories.update(partial_paths)

 def remove(self, pattern):
     """
     Remove paths matching the given pattern from the container. See the
     mozpack.path.match documentation for a description of the handled
     patterns.
     """
     items = self.match(pattern)
     if not items:
         return errors.error("Can't remove %s: %s" % (pattern, "not matching anything previously added"))
     for i in items:
         del self._files[i]

 def remove(self, pattern):
     '''
     Remove paths matching the given pattern from the container. See the
     mozpack.path.match documentation for a description of the handled
     patterns.
     '''
     items = self.match(pattern)
     if not items:
         return errors.error("Can't remove %s: %s" % (pattern,
                             "not matching anything previously added"))
     for i in items:
         del self._files[i]
         self._required_directories.subtract(self._partial_paths(i))

 def test_multiple_errors(self):
     with self.assertRaises(AccumulatedErrors):
         with errors.accumulate():
             errors.error('foo')
             for i in range(3):
                 if i == 2:
                     errors.warn('%d' % i)
                 else:
                     errors.error('%d' % i)
             errors.error('bar')
     self.assertEquals(self.get_output(),
                       ['Error: foo', 'Error: 0', 'Error: 1',
                        'Warning: 2', 'Error: bar'])

 def test_errors_context(self):
     with self.assertRaises(AccumulatedErrors):
         with errors.accumulate():
             self.assertEqual(errors.get_context(), None)
             with errors.context('foo', 1):
                 self.assertEqual(errors.get_context(), ('foo', 1))
                 errors.error('a')
                 with errors.context('bar', 2):
                     self.assertEqual(errors.get_context(), ('bar', 2))
                     errors.error('b')
                 self.assertEqual(errors.get_context(), ('foo', 1))
                 errors.error('c')
     self.assertEqual(self.get_output(), [
         'Error: foo:1: a',
         'Error: bar:2: b',
         'Error: foo:1: c',
     ])

def _repack(app_finder, l10n_finder, copier, formatter, non_chrome=set()):
    app = LocaleManifestFinder(app_finder)
    l10n = LocaleManifestFinder(l10n_finder)

    # The code further below assumes there's only one locale replaced with
    # another one.
    if len(app.locales) > 1 or len(l10n.locales) > 1:
        errors.fatal("Multiple locales aren't supported")
    locale = app.locales[0]
    l10n_locale = l10n.locales[0]

    # For each base directory, store what path a locale chrome package name
    # corresponds to.
    # e.g., for the following entry under app/chrome:
    #     locale foo en-US path/to/files
    # keep track that the locale path for foo in app is
    # app/chrome/path/to/files.
    l10n_paths = {}
    for e in l10n.entries:
        if isinstance(e, ManifestChrome):
            base = mozpath.basedir(e.path, app.bases)
            l10n_paths.setdefault(base, {})
            l10n_paths[base][e.name] = e.path

    # For chrome and non chrome files or directories, store what langpack path
    # corresponds to a package path.
    paths = {}
    for e in app.entries:
        if isinstance(e, ManifestEntryWithRelPath):
            base = mozpath.basedir(e.path, app.bases)
            if base not in l10n_paths:
                errors.fatal("Locale doesn't contain %s/" % base)
                # Allow errors to accumulate
                continue
            if e.name not in l10n_paths[base]:
                errors.fatal("Locale doesn't have a manifest entry for '%s'" %
                    e.name)
                # Allow errors to accumulate
                continue
            paths[e.path] = l10n_paths[base][e.name]

    for pattern in non_chrome:
        for base in app.bases:
            path = mozpath.join(base, pattern)
            left = set(p for p, f in app_finder.find(path))
            right = set(p for p, f in l10n_finder.find(path))
            for p in right:
                paths[p] = p
            for p in left - right:
                paths[p] = None

    # Create a new package, with non localized bits coming from the original
    # package, and localized bits coming from the langpack.
    packager = SimplePackager(formatter)
    for p, f in app_finder:
        if is_manifest(p):
            # Remove localized manifest entries.
            for e in [e for e in f if e.localized]:
                f.remove(e)
        # If the path is one that needs a locale replacement, use the
        # corresponding file from the langpack.
        path = None
        if p in paths:
            path = paths[p]
            if not path:
                continue
        else:
            base = mozpath.basedir(p, paths.keys())
            if base:
                subpath = mozpath.relpath(p, base)
                path = mozpath.normpath(mozpath.join(paths[base],
                                                               subpath))
        if path:
            files = [f for p, f in l10n_finder.find(path)]
            if not len(files):
                if base not in non_chrome:
                    errors.error("Missing file: %s" %
                                 os.path.join(l10n_finder.base, path))
            else:
                packager.add(path, files[0])
        else:
            packager.add(p, f)

    # Add localized manifest entries from the langpack.
    l10n_manifests = []
    for base in set(e.base for e in l10n.entries):
        m = ManifestFile(base, [e for e in l10n.entries if e.base == base])
        path = mozpath.join(base, 'chrome.%s.manifest' % l10n_locale)
        l10n_manifests.append((path, m))
    bases = packager.get_bases()
    for path, m in l10n_manifests:
        base = mozpath.basedir(path, bases)
        packager.add(path, m)
        # Add a "manifest $path" entry in the top manifest under that base.
        m = ManifestFile(base)
        m.add(Manifest(base, mozpath.relpath(path, base)))
        packager.add(mozpath.join(base, 'chrome.manifest'), m)

    packager.close()

#.........这里部分代码省略.........

 def test_simple_error(self):
     with self.assertRaises(AccumulatedErrors):
         with errors.accumulate():
             errors.error('1')
     self.assertEquals(self.get_output(), ['Error: 1'])

 def test_ignore_errors(self):
     errors.ignore_errors()
     errors.warn('foo')
     errors.error('bar')
     self.assertRaises(ErrorMessage, errors.fatal, 'foo')
     self.assertEquals(self.get_output(), ['Warning: foo', 'Warning: bar'])