Backed out changesets acbab9e22691 and 3c34fd480729 (bug 987360) for Android/B2G xpcshell bustage.
authorRyan VanderMeulen <ryanvm@gmail.com>
Fri, 27 Mar 2015 13:12:19 -0400
changeset 264986 f1b2cb81a3f334fedaf688a81450df11a975caa9
parent 264985 76f46106d07efc487dea8aa41a75d8b13bced72b
child 264987 67f8d63b2cadf9bf32d8b391292f41bae6d38bc2
push id4718
push userraliiev@mozilla.com
push dateMon, 11 May 2015 18:39:53 +0000
treeherdermozilla-beta@c20c4ef55f08 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
bugs987360
milestone39.0a1
backs outacbab9e2269188baa30e8bb06b770e810dcf9d83
3c34fd480729e3b6684fba747ff61078f672ce16
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Backed out changesets acbab9e22691 and 3c34fd480729 (bug 987360) for Android/B2G xpcshell bustage. CLOSED TREE
testing/marionette/client/marionette/runner/base.py
testing/marionette/mach_commands.py
testing/mochitest/mach_commands.py
testing/mochitest/mochitest_options.py
testing/mochitest/runtests.py
testing/mozbase/manifestparser/manifestparser/filters.py
testing/mozbase/manifestparser/manifestparser/manifestparser.py
testing/mozbase/manifestparser/tests/test_filters.py
testing/xpcshell/mach_commands.py
testing/xpcshell/runxpcshelltests.py
--- a/testing/marionette/client/marionette/runner/base.py
+++ b/testing/marionette/client/marionette/runner/base.py
@@ -12,17 +12,16 @@ import random
 import socket
 import sys
 import time
 import traceback
 import unittest
 import xml.dom.minidom as dom
 
 from manifestparser import TestManifest
-from manifestparser.filters import tags
 from marionette_driver.marionette import Marionette
 from mixins.b2g import B2GTestResultMixin, get_b2g_pid, get_dm
 from mozhttpd import MozHttpd
 from mozlog.structured.structuredlog import get_default_logger
 from moztest.adapters.unit import StructuredTestRunner, StructuredTestResult
 from moztest.results import TestResultCollection, TestResult, relevant_line
 import mozversion
 
@@ -413,22 +412,16 @@ class BaseMarionetteOptions(OptionParser
                         action='store',
                         default=self.socket_timeout_default,
                         help='Set the global timeout for marionette socket operations.')
         self.add_option('--e10s',
                         dest='e10s',
                         action='store_true',
                         default=False,
                         help='Enable e10s when running marionette tests.')
-        self.add_option('--tag',
-                        action='append', dest='test_tags',
-                        default=None,
-                        help="Filter out tests that don't have the given tag. Can be "
-                             "used multiple times in which case the test must contain "
-                             "at least one of the given tags.")
 
     def parse_args(self, args=None, values=None):
         options, tests = OptionParser.parse_args(self, args, values)
         for handler in self.parse_args_handlers:
             handler(options, tests, args, values)
 
         return (options, tests)
 
@@ -496,17 +489,17 @@ class BaseMarionetteTestRunner(object):
                  emulator_img=None, emulator_res='480x800', homedir=None,
                  app=None, app_args=None, binary=None, profile=None,
                  logger=None, no_window=False, logdir=None, logcat_stdout=False,
                  xml_output=None, repeat=0, testvars=None, tree=None, type=None,
                  device_serial=None, symbols_path=None, timeout=None,
                  shuffle=False, shuffle_seed=random.randint(0, sys.maxint),
                  sdcard=None, this_chunk=1, total_chunks=1, sources=None,
                  server_root=None, gecko_log=None, result_callbacks=None,
-                 adb_host=None, adb_port=None, prefs=None, test_tags=None,
+                 adb_host=None, adb_port=None, prefs=None,
                  socket_timeout=BaseMarionetteOptions.socket_timeout_default,
                  **kwargs):
         self.address = address
         self.emulator = emulator
         self.emulator_binary = emulator_binary
         self.emulator_img = emulator_img
         self.emulator_res = emulator_res
         self.homedir = homedir
@@ -542,17 +535,16 @@ class BaseMarionetteTestRunner(object):
         self.gecko_log = gecko_log
         self.mixin_run_tests = []
         self.manifest_skipped_tests = []
         self.tests = []
         self.result_callbacks = result_callbacks if result_callbacks is not None else []
         self._adb_host = adb_host
         self._adb_port = adb_port
         self.prefs = prefs or {}
-        self.test_tags = test_tags
 
         def gather_debug(test, status):
             rv = {}
             marionette = test._marionette_weakref()
 
             # In the event we're gathering debug without starting a session, skip marionette commands
             if marionette.session is not None:
                 try:
@@ -887,30 +879,21 @@ setReq.onerror = function() {
         testarg_b2g = bool(testargs.get('b2g'))
 
         file_ext = os.path.splitext(os.path.split(filepath)[-1])[1]
 
         if file_ext == '.ini':
             manifest = TestManifest()
             manifest.read(filepath)
 
-            filters = []
-            if self.test_tags:
-                filters.append(tags(self.test_tags))
             manifest_tests = manifest.active_tests(exists=False,
                                                    disabled=True,
-                                                   filters=filters,
                                                    device=self.device,
                                                    app=self.appName,
                                                    **mozinfo.info)
-            if len(manifest_tests) == 0:
-                self.logger.error("no tests to run using specified "
-                                  "combination of filters: {}".format(
-                                       manifest.fmt_filters()))
-
             unfiltered_tests = []
             for test in manifest_tests:
                 if test.get('disabled'):
                     self.manifest_skipped_tests.append(test)
                 else:
                     unfiltered_tests.append(test)
 
             target_tests = manifest.get(tests=unfiltered_tests, **testargs)
--- a/testing/marionette/mach_commands.py
+++ b/testing/marionette/mach_commands.py
@@ -83,20 +83,16 @@ class B2GCommands(MachCommandBase):
         for attr in ('b2g_home', 'device_name'):
             setattr(self, attr, getattr(context, attr, None))
     @Command('marionette-webapi', category='testing',
         description='Run a Marionette webapi test (test WebAPIs using marionette).',
         conditions=[conditions.is_b2g])
     @CommandArgument('--type',
         default='b2g',
         help='Test type, usually one of: browser, b2g, b2g-qemu.')
-    @CommandArgument('--tag', action='append', dest='test_tags',
-        help='Filter out tests that don\'t have the given tag. Can be used '
-             'multiple times in which case the test must contain at least one '
-             'of the given tags.')
     @CommandArgument('tests', nargs='*', metavar='TESTS',
         help='Path to test(s) to run.')
     def run_marionette_webapi(self, tests, **kwargs):
         emulator = None
         if self.device_name:
             if self.device_name.startswith('emulator'):
                 emulator = 'arm'
                 if 'x86' in self.device_name:
@@ -127,17 +123,13 @@ class MachCommands(MachCommandBase):
         help='Path to gecko log file, or "-" for stdout.')
     @CommandArgument('--jsdebugger', action='store_true',
         help='Enable the jsdebugger for marionette javascript.')
     @CommandArgument('--pydebugger',
         help='Enable python post-mortem debugger when a test fails.'
              ' Pass in the debugger you want to use, eg pdb or ipdb.')
     @CommandArgument('--e10s', action='store_true',
         help='Enable electrolysis for marionette tests (desktop only).')
-    @CommandArgument('--tag', action='append', dest='test_tags',
-        help='Filter out tests that don\'t have the given tag. Can be used '
-             'multiple times in which case the test must contain at least one '
-             'of the given tags.')
     @CommandArgument('tests', nargs='*', metavar='TESTS',
         help='Path to test(s) to run.')
     def run_marionette_test(self, tests, **kwargs):
         binary = self.get_binary_path('app')
         return run_marionette(tests, binary=binary, topsrcdir=self.topsrcdir, **kwargs)
--- a/testing/mochitest/mach_commands.py
+++ b/testing/mochitest/mach_commands.py
@@ -732,24 +732,16 @@ def MochitestCommand(func):
         default=None,
         help='The per-test timeout time in seconds (default: 60 seconds)')
     func = timeout(func)
 
     max_timeouts = CommandArgument('--max-timeouts', default=None,
         help='The maximum number of timeouts permitted before halting testing')
     func = max_timeouts(func)
 
-    tags = CommandArgument(
-        "--tag",
-        dest='test_tags', action='append',
-        help="Filter out tests that don't have the given tag. Can be used "
-             "multiple times in which case the test must contain at least one "
-             "of the given tags.")
-    func = tags(func)
-
     return func
 
 
 def B2GCommand(func):
     """Decorator that adds shared command arguments to b2g mochitest commands."""
 
     busybox = CommandArgument(
         '--busybox',
@@ -817,24 +809,16 @@ def B2GCommand(func):
     runUntilFailure = CommandArgument(
         "--run-until-failure",
         action='store_true',
         help='Run tests repeatedly and stops on the first time a test fails. '
         'Default cap is 30 runs, which can be overwritten '
         'with the --repeat parameter.')
     func = runUntilFailure(func)
 
-    tags = CommandArgument(
-        "--tag",
-        dest='test_tags', action='append',
-        help="Filter out tests that don't have the given tag. Can be used "
-             "multiple times in which case the test must contain at least one "
-             "of the given tags.")
-    func = tags(func)
-
     return func
 
 
 _st_parser = argparse.ArgumentParser()
 structured.commandline.add_logging_group(_st_parser)
 
 
 @CommandProvider
--- a/testing/mochitest/mochitest_options.py
+++ b/testing/mochitest/mochitest_options.py
@@ -465,24 +465,16 @@ class MochitestOptions(optparse.OptionPa
           "help": "prevents the test harness from redirecting stdout and stderr for interactive debuggers",
           }],
         [["--max-timeouts"],
          { "type": "int",
            "dest": "maxTimeouts",
            "help": "maximum number of timeouts permitted before halting testing",
            "default": None,
            }],
-        [["--tag"],
-         { "action": "append",
-           "dest": "test_tags",
-           "default": None,
-           "help": "filter out tests that don't have the given tag. Can be "
-                   "used multiple times in which case the test must contain "
-                   "at least one of the given tags.",
-         }],
     ]
 
     def __init__(self, **kwargs):
 
         optparse.OptionParser.__init__(self, **kwargs)
         for option, value in self.mochitest_options:
             # Allocate new lists so references to original don't get mutated.
             # allowing multiple uses within a single process.
--- a/testing/mochitest/runtests.py
+++ b/testing/mochitest/runtests.py
@@ -45,17 +45,16 @@ from automationutils import (
 )
 
 from datetime import datetime
 from manifestparser import TestManifest
 from manifestparser.filters import (
     chunk_by_dir,
     chunk_by_slice,
     subsuite,
-    tags,
 )
 from mochitest_options import MochitestOptions
 from mozprofile import Profile, Preferences
 from mozprofile.permissions import ServerLocations
 from urllib import quote_plus as encodeURIComponent
 from mozlog.structured.formatters import TbplFormatter
 from mozlog.structured import commandline
 
@@ -1889,27 +1888,21 @@ class Mochitest(MochitestUtilsMixin):
                 # Add chunking filters if specified
                 if options.chunkByDir:
                     filters.append(chunk_by_dir(options.thisChunk,
                                                 options.totalChunks,
                                                 options.chunkByDir))
                 elif options.totalChunks:
                     filters.append(chunk_by_slice(options.thisChunk,
                                                   options.totalChunks))
-
-                if options.test_tags:
-                    filters.append(tags(options.test_tags))
-
                 tests = manifest.active_tests(
                     exists=False, disabled=disabled, filters=filters, **info)
-
                 if len(tests) == 0:
-                    self.log.error("no tests to run using specified "
-                                   "combination of filters: {}".format(
-                                        manifest.fmt_filters()))
+                    tests = manifest.active_tests(
+                        exists=False, disabled=True, **info)
 
         paths = []
 
         for test in tests:
             if len(tests) == 1 and 'disabled' in test:
                 del test['disabled']
 
             pathAbs = os.path.abspath(test['path'])
--- a/testing/mozbase/manifestparser/manifestparser/filters.py
+++ b/testing/mozbase/manifestparser/manifestparser/filters.py
@@ -79,32 +79,20 @@ def exists(tests, values):
 
 # built-in instance filters
 
 class InstanceFilter(object):
     """
     Generally only one instance of a class filter should be applied at a time.
     Two instances of `InstanceFilter` are considered equal if they have the
     same class name. This ensures only a single instance is ever added to
-    `filterlist`. This class also formats filters' __str__ method for easier
-    debugging.
+    `filterlist`.
     """
-    unique = True
-    def __init__(self, *args, **kwargs):
-        self.fmt_args = ', '.join(itertools.chain(
-            [str(a) for a in args],
-            ['{}={}'.format(k, v) for k, v in kwargs.iteritems()]))
-
     def __eq__(self, other):
-        if self.unique:
-            return self.__class__ == other.__class__
-        return self.__hash__() == other.__hash__()
-
-    def __str__(self):
-        return "{}({})".format(self.__class__.__name__, self.fmt_args)
+        return self.__class__ == other.__class__
 
 
 class subsuite(InstanceFilter):
     """
     If `name` is None, removes all tests that have a `subsuite` key.
     Otherwise removes all tests that do not have a subsuite matching `name`.
 
     It is possible to specify conditional subsuite keys using:
@@ -112,17 +100,16 @@ class subsuite(InstanceFilter):
 
     where 'foo' is the subsuite name, and 'condition' is the same type of
     condition used for skip-if.  If the condition doesn't evaluate to true,
     the subsuite designation will be removed from the test.
 
     :param name: The name of the subsuite to run (default None)
     """
     def __init__(self, name=None):
-        InstanceFilter.__init__(self, name=name)
         self.name = name
 
     def __call__(self, tests, values):
         # Look for conditional subsuites, and replace them with the subsuite
         # itself (if the condition is true), or nothing.
         for test in tests:
             subsuite = test.get('subsuite', '')
             if ',' in subsuite:
@@ -154,18 +141,16 @@ class chunk_by_slice(InstanceFilter):
     :param disabled: Whether to include disabled tests in the chunking
                      algorithm. If False, each chunk contains an equal number
                      of non-disabled tests. If True, each chunk contains an
                      equal number of tests (default False)
     """
 
     def __init__(self, this_chunk, total_chunks, disabled=False):
         assert 1 <= this_chunk <= total_chunks
-        InstanceFilter.__init__(self, this_chunk, total_chunks,
-                                disabled=disabled)
         self.this_chunk = this_chunk
         self.total_chunks = total_chunks
         self.disabled = disabled
 
     def __call__(self, tests, values):
         tests = list(tests)
         if self.disabled:
             chunk_tests = tests[:]
@@ -206,17 +191,16 @@ class chunk_by_dir(InstanceFilter):
 
     :param this_chunk: the current chunk, 1 <= this_chunk <= total_chunks
     :param total_chunks: the total number of chunks
     :param depth: the minimum depth of a subdirectory before it will be
                   considered unique
     """
 
     def __init__(self, this_chunk, total_chunks, depth):
-        InstanceFilter.__init__(self, this_chunk, total_chunks, depth)
         self.this_chunk = this_chunk
         self.total_chunks = total_chunks
         self.depth = depth
 
     def __call__(self, tests, values):
         tests_by_dir = defaultdict(list)
         ordered_dirs = []
         for test in tests:
@@ -261,17 +245,16 @@ class chunk_by_runtime(InstanceFilter):
 
     :param this_chunk: the current chunk, 1 <= this_chunk <= total_chunks
     :param total_chunks: the total number of chunks
     :param runtimes: dictionary of test runtime data, of the form
                      {<test path>: <average runtime>}
     """
 
     def __init__(self, this_chunk, total_chunks, runtimes):
-        InstanceFilter.__init__(self, this_chunk, total_chunks, runtimes)
         self.this_chunk = this_chunk
         self.total_chunks = total_chunks
 
         # defaultdict(int) assigns all non-existent keys a value of 0. This
         # essentially means all tests we encounter that don't exist in the
         # runtimes file won't factor in to the chunking determination.
         self.runtimes = defaultdict(int)
         self.runtimes.update(runtimes)
@@ -297,41 +280,16 @@ class chunk_by_runtime(InstanceFilter):
             # get the next batch of tests.
             tests_by_chunk.sort(key=lambda x: (x[0], len(x[1])))
             tests_by_chunk[0][0] += runtime
             tests_by_chunk[0][1].extend(batch)
 
         return (t for t in tests_by_chunk[self.this_chunk-1][1])
 
 
-class tags(InstanceFilter):
-    """
-    Removes tests that don't contain any of the given tags. This overrides
-    InstanceFilter's __eq__ method, so multiple instances can be added.
-    Multiple tag filters is equivalent to joining tags with the AND operator.
-
-    :param tags: A tag or list of tags to filter tests on
-    """
-    unique = False
-    def __init__(self, tags):
-        InstanceFilter.__init__(self, tags)
-        if isinstance(tags, basestring):
-            tags = [tags]
-        self.tags = tags
-
-    def __call__(self, tests, values):
-        for test in tests:
-            if 'tags' not in test:
-                continue
-
-            test_tags = [t.strip() for t in test['tags'].split(',')]
-            if any(t in self.tags for t in test_tags):
-                yield test
-
-
 # filter container
 
 DEFAULT_FILTERS = (
     skip_if,
     run_if,
     fail_if,
 )
 """
--- a/testing/mozbase/manifestparser/manifestparser/manifestparser.py
+++ b/testing/mozbase/manifestparser/manifestparser/manifestparser.py
@@ -5,17 +5,16 @@
 __all__ = ['ManifestParser', 'TestManifest', 'convert']
 
 from StringIO import StringIO
 import json
 import fnmatch
 import os
 import shutil
 import sys
-import types
 
 from .ini import read_ini
 from .filters import (
     DEFAULT_FILTERS,
     enabled,
     exists as _exists,
     filterlist,
 )
@@ -706,17 +705,16 @@ class TestManifest(ManifestParser):
     """
     apply logic to manifests;  this is your integration layer :)
     specific harnesses may subclass from this if they need more logic
     """
 
     def __init__(self, *args, **kwargs):
         ManifestParser.__init__(self, *args, **kwargs)
         self.filters = filterlist(DEFAULT_FILTERS)
-        self.last_used_filters = []
 
     def active_tests(self, exists=True, disabled=True, filters=None, **values):
         """
         Run all applied filters on the set of tests.
 
         :param exists: filter out non-existing tests (default True)
         :param disabled: whether to return disabled tests (default True)
         :param values: keys and values to filter on (e.g. `os = linux mac`)
@@ -738,25 +736,14 @@ class TestManifest(ManifestParser):
                 fltrs.append(_exists)
 
         if not disabled:
             fltrs.append(enabled)
 
         if filters:
             fltrs += filters
 
-        self.last_used_filters = fltrs[:]
         for fn in fltrs:
             tests = fn(tests, values)
         return list(tests)
 
     def test_paths(self):
         return [test['path'] for test in self.active_tests()]
-
-    def fmt_filters(self, filters=None):
-        filters = filters or self.last_used_filters
-        names = []
-        for f in filters:
-            if isinstance(f, types.FunctionType):
-                names.append(f.__name__)
-            else:
-                names.append(str(f))
-        return ', '.join(names)
--- a/testing/mozbase/manifestparser/tests/test_filters.py
+++ b/testing/mozbase/manifestparser/tests/test_filters.py
@@ -1,21 +1,22 @@
 #!/usr/bin/env python
 
 from copy import deepcopy
 import os
 import unittest
 
+from manifestparser import TestManifest
 from manifestparser.filters import (
     subsuite,
-    tags,
     skip_if,
     run_if,
     fail_if,
     enabled,
+    exists,
     filterlist,
 )
 
 here = os.path.dirname(os.path.abspath(__file__))
 
 
 class FilterList(unittest.TestCase):
     """Test filterlist datatype"""
@@ -41,46 +42,35 @@ class FilterList(unittest.TestCase):
 
         self.assertEquals(fl.index(foo), 0)
 
         del fl[0]
         self.assertFalse(foo in fl)
         with self.assertRaises(IndexError):
             fl[0]
 
-    def test_add_non_callable_to_list(self):
+    def test_add_non_callable_to_set(self):
         fl = filterlist()
         with self.assertRaises(TypeError):
             fl.append('foo')
 
-    def test_add_duplicates_to_list(self):
+    def test_add_duplicates_to_set(self):
         foo = lambda x, y: x
         bar = lambda x, y: x
         sub = subsuite('foo')
         fl = filterlist([foo, bar, sub])
         self.assertEquals(len(fl), 3)
         self.assertEquals(fl[0], foo)
 
         with self.assertRaises(ValueError):
             fl.append(foo)
 
         with self.assertRaises(ValueError):
             fl.append(subsuite('bar'))
 
-    def test_add_two_tags_filters(self):
-        tag1 = tags('foo')
-        tag2 = tags('bar')
-        fl = filterlist([tag1])
-
-        with self.assertRaises(ValueError):
-            fl.append(tag1)
-
-        fl.append(tag2)
-        self.assertEquals(len(fl), 2)
-
     def test_filters_run_in_order(self):
         a = lambda x, y: x
         b = lambda x, y: x
         c = lambda x, y: x
         d = lambda x, y: x
         e = lambda x, y: x
         f = lambda x, y: x
 
@@ -90,25 +80,23 @@ class FilterList(unittest.TestCase):
         fl += [f]
         self.assertEquals([i for i in fl], [a, b, c, d, e, f])
 
 
 class BuiltinFilters(unittest.TestCase):
     """Test the built-in filters"""
 
     tests = (
-        {"name": "test0"},
-        {"name": "test1", "skip-if": "foo == 'bar'"},
-        {"name": "test2", "run-if": "foo == 'bar'"},
-        {"name": "test3", "fail-if": "foo == 'bar'"},
-        {"name": "test4", "disabled": "some reason"},
-        {"name": "test5", "subsuite": "baz"},
-        {"name": "test6", "subsuite": "baz,foo == 'bar'"},
-        {"name": "test7", "tags": "foo, bar"},
-    )
+        { "name": "test0" },
+        { "name": "test1", "skip-if": "foo == 'bar'" },
+        { "name": "test2", "run-if": "foo == 'bar'" },
+        { "name": "test3", "fail-if": "foo == 'bar'" },
+        { "name": "test4", "disabled": "some reason" },
+        { "name": "test5", "subsuite": "baz" },
+        { "name": "test6", "subsuite": "baz,foo == 'bar'" })
 
     def test_skip_if(self):
         tests = deepcopy(self.tests)
         tests = list(skip_if(tests, {}))
         self.assertEquals(len(tests), len(self.tests))
 
         tests = deepcopy(self.tests)
         tests = list(skip_if(tests, {'foo': 'bar'}))
@@ -139,17 +127,17 @@ class BuiltinFilters(unittest.TestCase):
 
     def test_subsuite(self):
         sub1 = subsuite()
         sub2 = subsuite('baz')
 
         tests = deepcopy(self.tests)
         tests = list(sub1(tests, {}))
         self.assertNotIn(self.tests[5], tests)
-        self.assertEquals(len(tests), len(self.tests)-1)
+        self.assertEquals(tests[-1]['name'], 'test6')
 
         tests = deepcopy(self.tests)
         tests = list(sub2(tests, {}))
         self.assertEquals(len(tests), 1)
         self.assertIn(self.tests[5], tests)
 
     def test_subsuite_condition(self):
         sub1 = subsuite()
@@ -161,21 +149,8 @@ class BuiltinFilters(unittest.TestCase):
         self.assertNotIn(self.tests[5], tests)
         self.assertNotIn(self.tests[6], tests)
 
         tests = deepcopy(self.tests)
         tests = list(sub2(tests, {'foo': 'bar'}))
         self.assertEquals(len(tests), 2)
         self.assertEquals(tests[0]['name'], 'test5')
         self.assertEquals(tests[1]['name'], 'test6')
-
-    def test_tags(self):
-        ftags1 = tags([])
-        ftags2 = tags(['bar', 'baz'])
-
-        tests = deepcopy(self.tests)
-        tests = list(ftags1(tests, {}))
-        self.assertEquals(len(tests), 0)
-
-        tests = deepcopy(self.tests)
-        tests = list(ftags2(tests, {}))
-        self.assertEquals(len(tests), 1)
-        self.assertIn(self.tests[7], tests)
--- a/testing/xpcshell/mach_commands.py
+++ b/testing/xpcshell/mach_commands.py
@@ -62,17 +62,17 @@ class XPCShellRunner(MozbuildObject):
 
         return self._run_xpcshell_harness(manifest=manifest, **kwargs)
 
     def run_test(self, test_paths, interactive=False,
                  keep_going=False, sequential=False, shuffle=False,
                  debugger=None, debuggerArgs=None, debuggerInteractive=None,
                  jsDebugger=False, jsDebuggerPort=None,
                  rerun_failures=False, test_objects=None, verbose=False,
-                 log=None, test_tags=None,
+                 log=None,
                  # ignore parameters from other platforms' options
                  **kwargs):
         """Runs an individual xpcshell test."""
         from mozbuild.testing import TestResolver
         from manifestparser import TestManifest
 
         # TODO Bug 794506 remove once mach integrates with virtualenv.
         build_path = os.path.join(self.topobjdir, 'build')
@@ -84,17 +84,17 @@ class XPCShellRunner(MozbuildObject):
 
         if test_paths == ['all']:
             self.run_suite(interactive=interactive,
                            keep_going=keep_going, shuffle=shuffle, sequential=sequential,
                            debugger=debugger, debuggerArgs=debuggerArgs,
                            debuggerInteractive=debuggerInteractive,
                            jsDebugger=jsDebugger, jsDebuggerPort=jsDebuggerPort,
                            rerun_failures=rerun_failures,
-                           verbose=verbose, log=log, test_tags=test_tags)
+                           verbose=verbose, log=log)
             return
         elif test_paths:
             test_paths = [self._wrap_path_argument(p).relpath() for p in test_paths]
 
         if test_objects:
             tests = test_objects
         else:
             resolver = self._spawn(TestResolver)
@@ -119,27 +119,26 @@ class XPCShellRunner(MozbuildObject):
             'debuggerArgs': debuggerArgs,
             'debuggerInteractive': debuggerInteractive,
             'jsDebugger': jsDebugger,
             'jsDebuggerPort': jsDebuggerPort,
             'rerun_failures': rerun_failures,
             'manifest': manifest,
             'verbose': verbose,
             'log': log,
-            'test_tags': test_tags,
         }
 
         return self._run_xpcshell_harness(**args)
 
     def _run_xpcshell_harness(self, manifest,
                               test_path=None, shuffle=False, interactive=False,
                               keep_going=False, sequential=False,
                               debugger=None, debuggerArgs=None, debuggerInteractive=None,
                               jsDebugger=False, jsDebuggerPort=None,
-                              rerun_failures=False, verbose=False, log=None, test_tags=None):
+                              rerun_failures=False, verbose=False, log=None):
 
         # Obtain a reference to the xpcshell test runner.
         import runxpcshelltests
 
         xpcshell = runxpcshelltests.XPCShellTests(log=log)
         self.log_manager.enable_unstructured()
 
         tests_dir = os.path.join(self.topobjdir, '_tests', 'xpcshell')
@@ -167,17 +166,16 @@ class XPCShellRunner(MozbuildObject):
             'xunitFilename': os.path.join(self.statedir, 'xpchsell.xunit.xml'),
             'xunitName': 'xpcshell',
             'pluginsPath': os.path.join(self.distdir, 'plugins'),
             'debugger': debugger,
             'debuggerArgs': debuggerArgs,
             'debuggerInteractive': debuggerInteractive,
             'jsDebugger': jsDebugger,
             'jsDebuggerPort': jsDebuggerPort,
-            'test_tags': test_tags,
         }
 
         if test_path is not None:
             args['testPath'] = test_path
 
         # A failure manifest is written by default. If --rerun-failures is
         # specified and a prior failure manifest is found, the prior manifest
         # will be run. A new failure manifest is always written over any
@@ -435,20 +433,16 @@ class MachCommands(MachCommandBase):
     @CommandArgument('--keep-going', '-k', action='store_true',
         help='Continue running tests after a SIGINT is received.')
     @CommandArgument('--sequential', action='store_true',
         help='Run the tests sequentially.')
     @CommandArgument('--shuffle', '-s', action='store_true',
         help='Randomize the execution order of tests.')
     @CommandArgument('--rerun-failures', action='store_true',
         help='Reruns failures from last time.')
-    @CommandArgument('--tag', action='append', dest='test_tags',
-        help='Filter out tests that don\'t have the given tag. Can be used '
-             'multiple times in which case the test must contain at least one '
-             'of the given tags.')
     @CommandArgument('--devicemanager', default='adb', type=str,
         help='(Android) Type of devicemanager to use for communication: adb or sut')
     @CommandArgument('--ip', type=str, default=None,
         help='(Android) IP address of device')
     @CommandArgument('--port', type=int, default=20701,
         help='(Android) Port of device')
     @CommandArgument('--remote_test_root', type=str, default=None,
         help='(Android) Remote test root such as /mnt/sdcard or /data/local')
--- a/testing/xpcshell/runxpcshelltests.py
+++ b/testing/xpcshell/runxpcshelltests.py
@@ -56,17 +56,17 @@ EXPECTED_LOG_ACTIONS = set([
 here = os.path.dirname(__file__)
 mozbase = os.path.realpath(os.path.join(os.path.dirname(here), 'mozbase'))
 
 if os.path.isdir(mozbase):
     for package in os.listdir(mozbase):
         sys.path.append(os.path.join(mozbase, package))
 
 from manifestparser import TestManifest
-from manifestparser.filters import chunk_by_slice, tags
+from manifestparser.filters import chunk_by_slice
 from mozlog import structured
 import mozcrash
 import mozinfo
 
 # --------------------------------------------------------------
 
 # TODO: perhaps this should be in a more generally shared location?
 # This regex matches all of the C0 and C1 control characters
@@ -747,17 +747,17 @@ class XPCShellTestThread(Thread):
 class XPCShellTests(object):
 
     def __init__(self, log=None):
         """ Initializes node status and logger. """
         self.log = log
         self.harness_timeout = HARNESS_TIMEOUT
         self.nodeProc = {}
 
-    def buildTestList(self, test_tags=None):
+    def buildTestList(self):
         """
           read the xpcshell.ini manifest and set self.alltests to be
           an array of test objects.
 
           if we are chunking tests, it will be done here as well
         """
         if isinstance(self.manifest, TestManifest):
             mp = self.manifest
@@ -768,32 +768,25 @@ class XPCShellTests(object):
                     if testdir:
                         mp.read(os.path.join(testdir, 'xpcshell.ini'))
             else:
                 mp.read(self.manifest)
 
         self.buildTestPath()
 
         filters = []
-        if test_tags:
-            filters.append(tags(test_tags))
-
         if self.singleFile is None and self.totalChunks > 1:
             filters.append(chunk_by_slice(self.thisChunk, self.totalChunks))
+
         try:
             self.alltests = mp.active_tests(filters=filters, **mozinfo.info)
         except TypeError:
             sys.stderr.write("*** offending mozinfo.info: %s\n" % repr(mozinfo.info))
             raise
 
-        if len(self.alltests) == 0:
-            self.log.error("no tests to run using specified "
-                           "combination of filters: {}".format(
-                                mp.fmt_filters()))
-
     def setAbsPath(self):
         """
           Set the absolute path for xpcshell, httpdjspath and xrepath.
           These 3 variables depend on input from the command line and we need to allow for absolute paths.
           This function is overloaded for a remote solution as os.path* won't work remotely.
         """
         self.testharnessdir = os.path.dirname(os.path.abspath(__file__))
         self.headJSPath = self.testharnessdir.replace("\\", "/") + "/head.js"
@@ -1018,17 +1011,17 @@ class XPCShellTests(object):
                  manifest=None, testdirs=None, testPath=None, mobileArgs=None,
                  interactive=False, verbose=False, keepGoing=False, logfiles=True,
                  thisChunk=1, totalChunks=1, debugger=None,
                  debuggerArgs=None, debuggerInteractive=False,
                  profileName=None, mozInfo=None, sequential=False, shuffle=False,
                  testsRootDir=None, testingModulesDir=None, pluginsPath=None,
                  testClass=XPCShellTestThread, failureManifest=None,
                  log=None, stream=None, jsDebugger=False, jsDebuggerPort=0,
-                 test_tags=None, **otherOptions):
+                 **otherOptions):
         """Run xpcshell tests.
 
         |xpcshell|, is the xpcshell executable to use to run the tests.
         |xrePath|, if provided, is the path to the XRE to use.
         |appPath|, if provided, is the path to an application directory.
         |symbolsPath|, if provided is the path to a directory containing
           breakpad symbols for processing crashes in tests.
         |manifest|, if provided, is a file containing a list of
@@ -1166,17 +1159,17 @@ class XPCShellTests(object):
             appDirKey = self.mozInfo["appname"] + "-appdir"
 
         # We have to do this before we build the test list so we know whether or
         # not to run tests that depend on having the node spdy server
         self.trySetupNode()
 
         pStdout, pStderr = self.getPipes()
 
-        self.buildTestList(test_tags)
+        self.buildTestList()
         if self.singleFile:
             self.sequential = True
 
         if shuffle:
             random.shuffle(self.alltests)
 
         self.cleanup_dir_list = []
         self.try_again_list = []
@@ -1469,22 +1462,16 @@ class XPCShellOptions(OptionParser):
                           "stdout and stderr for interactive debuggers")
         self.add_option("--jsdebugger", dest="jsDebugger", action="store_true",
                         help="Waits for a devtools JS debugger to connect before "
                              "starting the test.")
         self.add_option("--jsdebugger-port", type="int", dest="jsDebuggerPort",
                         default=6000,
                         help="The port to listen on for a debugger connection if "
                              "--jsdebugger is specified.")
-        self.add_option("--tag",
-                        action="append", dest="test_tags",
-                        default=None,
-                        help="filter out tests that don't have the given tag. Can be "
-                             "used multiple times in which case the test must contain "
-                             "at least one of the given tags.")
 
 def main():
     parser = XPCShellOptions()
     structured.commandline.add_logging_group(parser)
     options, args = parser.parse_args()
 
 
     log = structured.commandline.setup_logging("XPCShell",