def wrapped(_class, simple=False, skip=None, require=None, flows=None):
            if type(_class) == FunctionType:
                _class = make_test_case_class_from_function(
                    _class,
                    simple=simple,
                    base_class=self.TestCase,
                )

            if flows:
                for method_name in loader.load_test_names_from_test_case(_class):
                    setattr(_class, method_name, _flows(*flows)(getattr(_class, method_name)))

            if skip:
                unittest.skip(skip)(_class)

            if hasattr(_class, 'REQUIRE'):
                raise RuntimeError('"REQUIRE" attribute can not be pre set')

            if require:
                setattr(_class, 'REQUIRE', require)

            self.__context.add_test_case(_class)

            logger.debug(
                'Register test case "{}" on {}'.format(
                    _class.__name__, repr(self),
                ),
            )

            return _class

def needs_aws(test_item):
    """
    Use as a decorator before test classes or methods to only run them if AWS usable.
    """
    test_item = _mark_test('aws', test_item)
    try:
        # noinspection PyUnresolvedReferences
        import boto
    except ImportError:
        return unittest.skip("Skipping test. Install toil with the 'aws' extra to include this "
                             "test.")(test_item)
    except:
        raise
    else:
        dot_boto_path = os.path.expanduser('~/.boto')
        dot_aws_credentials_path = os.path.expanduser('~/.aws/credentials')
        hv_uuid_path = '/sys/hypervisor/uuid'
        if (os.path.exists(dot_boto_path)
            or os.path.exists(dot_aws_credentials_path)
            # Assume that EC2 machines like the Jenkins slave that we run CI on will have IAM roles
            or os.path.exists(hv_uuid_path) and file_begins_with(hv_uuid_path,'ec2')):
            return test_item
        else:
            return unittest.skip("Skipping test. Create ~/.boto or ~/.aws/credentials to include "
                                 "this test.")(test_item)

 def decorate_it(f):
     if hide_skipped_tests:
         ret_val = unittest.skip(msg_or_f)
         ret_val.__name__ = '_pretty_skipped_function'
         return ret_val
     else:
         return unittest.skip(msg_or_f)(f)

def requires_resource(resource):
    if resource == "gui" and not _is_gui_available():
        return unittest.skip("resource 'gui' is not available")
    if is_resource_enabled(resource):
        return _id
    else:
        return unittest.skip("resource {0!r} is not enabled".format(resource))

def skipUnlessPG92(test):
    if not connection.vendor == 'postgresql':
        return unittest.skip('PostgreSQL required')(test)
    PG_VERSION = connection.pg_version
    if PG_VERSION < 90200:
        return unittest.skip('PostgreSQL >= 9.2 required')(test)
    return test

def patch_wagtail_settings():
    # fix fixture paths to be absolute paths
    from wagtail import tests
    from wagtail.wagtailimages.tests import test_models
    fixture_path = os.path.join(
        os.path.dirname(tests.__file__), 'fixtures', 'test.json')
    test_models.TestUsageCount.fixtures = [fixture_path]
    test_models.TestGetUsage.fixtures = [fixture_path]
    test_models.TestGetWillowImage.fixtures = [fixture_path]
    from wagtail.wagtailimages.tests import tests
    tests.TestMissingImage.fixtures = [fixture_path]
    from wagtail.wagtailimages.tests import test_rich_text
    test_rich_text.TestImageEmbedHandler.fixtures = [fixture_path]

    # skip these test - they rely on media URL matching filename
    from wagtail.wagtailimages.tests.tests import TestMissingImage
    TestMissingImage.test_image_tag_with_missing_image = \
        unittest.skip('Unsupported')(
            TestMissingImage.test_image_tag_with_missing_image)
    TestMissingImage.test_rich_text_with_missing_image = \
        unittest.skip('Unsupported')(
            TestMissingImage.test_rich_text_with_missing_image)

    # filter these warnings
    import warnings
    warnings.simplefilter('default', DeprecationWarning)
    warnings.simplefilter('default', PendingDeprecationWarning)

    def test_start_with_two_args(self):
        if not self.open_argument.startswith('/'):
            unittest.skip("Only relevant for base class")

        path = os.path.join( self.app_dir, 'dist/argv.txt')
        if os.path.exists(path):
            os.unlink(path)

        self.maxDiff = None
        path = os.path.join( self.app_dir, 'dist/BasicApp.app')

        p = subprocess.Popen(["/usr/bin/open",
                '-a', path, "--args", "one", "two", "three"])
        exit = p.wait()
        self.assertEqual(exit, 0)

        path = os.path.join( self.app_dir, 'dist/argv.txt')
        for x in range(70):     # Argv emulation can take up-to 60 seconds
            time.sleep(1)
            if os.path.exists(path):
                break

        self.assertTrue(os.path.isfile(path))

        fp = open(path, 'r')
        data = fp.read().strip()
        fp.close()

        self.assertEqual(data.strip(), repr([os.path.join(self.app_dir, 'dist/BasicApp.app/Contents/Resources/main.py'), "one", "two", "three"]))

	def test_connect_kat(self):
		"""Testing connection to KickAssTorrent"""
		if any('kat' == providers['provider_type'] for providers in self.ts['providers']):
			self.ts.connect_provider('kat')
			self.ts.test()
		else:
			unittest.skip("KickAssTorrent is not setup".encode('utf8'))

	def test_connect_t411(self):
		"""Testing connection to T411"""
		if any('t411' == providers['provider_type'] for providers in self.ts['providers']):
			self.ts.connect_provider('t411')
			self.ts.test()
		else:
			unittest.skip("T411 is not setup".encode('utf8'))

def needs_aws(test_item):
    """
    Use as a decorator before test classes or methods to only run them if AWS usable.
    """
    test_item = _mark_test('aws', test_item)
    try:
        # noinspection PyUnresolvedReferences
        from boto import config
    except ImportError:
        return unittest.skip("Install toil with the 'aws' extra to include this test.")(test_item)
    except:
        raise
    else:
        dot_aws_credentials_path = os.path.expanduser('~/.aws/credentials')
        hv_uuid_path = '/sys/hypervisor/uuid'
        boto_credentials = config.get('Credentials', 'aws_access_key_id')
        if boto_credentials:
            return test_item
        if (os.path.exists(dot_aws_credentials_path) or
                (os.path.exists(hv_uuid_path) and file_begins_with(hv_uuid_path, 'ec2'))):
            # Assume that EC2 machines like the Jenkins slave that we run CI on will have IAM roles
            return test_item
        else:
            return unittest.skip("Configure ~/.aws/credentials with AWS credentials to include "
                                 "this test.")(test_item)

    def test_compile(self):
        # type: () -> None
        """Exercise the code generator so code coverage can be measured."""
        base_dir = os.path.dirname(
            os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
        src_dir = os.path.join(
            base_dir,
            'src',
        )
        idl_dir = os.path.join(src_dir, 'mongo', 'idl')

        args = idl.compiler.CompilerArgs()
        args.output_suffix = "_codecoverage_gen"
        args.import_directories = [src_dir]

        unittest_idl_file = os.path.join(idl_dir, 'unittest.idl')
        if not os.path.exists(unittest_idl_file):
            unittest.skip("Skipping IDL Generator testing since %s could not be found." %
                          (unittest_idl_file))
            return

        args.input_file = os.path.join(idl_dir, 'unittest_import.idl')
        self.assertTrue(idl.compiler.compile_idl(args))

        args.input_file = unittest_idl_file
        self.assertTrue(idl.compiler.compile_idl(args))

def skipUnlessTrue(descriptor):
    if not hasattr(config, descriptor):
        return unittest.skip("%s not defined in config.py, skipping" % descriptor)
    if getattr(config, descriptor) == 0:
        return unittest.skip("%s set to False in config.py, skipping" % descriptor)
    else:
        return lambda func: func

 def __init__(cls, name, bases, dct):
   super(SkipTestsMeta, cls).__init__(name, bases, dct)
   if cls.__name__ == "DatastoreInputReaderBaseTest":
     unittest.skip("Skip tests when testing from the base class.")(cls)
   else:
     # Since there is no unittest.unskip(), do it manually.
     cls.__unittest_skip__ = False
     cls.__unittest_skip_why__ = None

 def __init__(self, *args, **kwargs):
     super(OptimizedStaticFilesStorageTestsMixin, self).__init__(*args, **kwargs)
     if not self.has_environment():
         skip_message = "No {environment} present.".format(environment=self.require_environment)
         self.testCollectStatic = unittest.skip(skip_message)(self.testCollectStatic)
         self.testCollectStaticBuildProfile = unittest.skip(skip_message)(self.testCollectStaticBuildProfile)
         self.testCollectStaticStandalone = unittest.skip(skip_message)(self.testCollectStaticStandalone)
         self.testCollectStaticStandaloneBuildProfile = unittest.skip(skip_message)(self.testCollectStaticStandaloneBuildProfile)

def requiresSphinx():
    """ A decorator: a test requires Sphinx """
    if sphinxIsAvailable:
        return lambda func: func
    elif sphinxVersion is not None:
        return unittest.skip('Sphinx is too old. {} required'.format(_SPHINX_VERSION))
    else:
        return unittest.skip('Sphinx not found')

def skip_unless_galaxy(min_release=None):
    """ Decorate tests with this to skip the test if Galaxy is not
    configured.
    """
    if min_release is not None:
        galaxy_release = os.environ.get('GALAXY_VERSION', None)
        if galaxy_release is not None and galaxy_release != 'dev':
            if not galaxy_release.startswith('release_'):
                raise ValueError("The value of GALAXY_VERSION environment variable should start with 'release_'")
            if not min_release.startswith('release_'):
                raise Exception("min_release should start with 'release_'")
            if galaxy_release[8:] < min_release[8:]:
                return unittest.skip(OLD_GALAXY_RELEASE % (galaxy_release, min_release))

    if 'BIOBLEND_GALAXY_URL' not in os.environ:
        return unittest.skip(NO_GALAXY_MESSAGE)

    if 'BIOBLEND_GALAXY_API_KEY' not in os.environ and 'BIOBLEND_GALAXY_MASTER_API_KEY' in os.environ:
        galaxy_url = os.environ['BIOBLEND_GALAXY_URL']
        galaxy_master_api_key = os.environ['BIOBLEND_GALAXY_MASTER_API_KEY']
        gi = bioblend.galaxy.GalaxyInstance(galaxy_url, galaxy_master_api_key)

        if 'BIOBLEND_GALAXY_USER_EMAIL' in os.environ:
            galaxy_user_email = os.environ['BIOBLEND_GALAXY_USER_EMAIL']
        else:
            galaxy_user_email = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(5)) + "@localhost.localdomain"

        galaxy_user_id = None
        for user in gi.users.get_users():
            if user["email"] == galaxy_user_email:
                galaxy_user_id = user["id"]
                break

        if galaxy_user_id is None:
            try:
                config = gi.config.get_config()
            except Exception:
                # If older Galaxy for instance just assume use_remote_user is False.
                config = {}

            if config.get("use_remote_user", False):
                new_user = gi.users.create_remote_user(galaxy_user_email)
            else:
                galaxy_user = galaxy_user_email.split("@", 1)[0]
                galaxy_password = ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(20))

                # Create a new user and get a new API key for her
                new_user = gi.users.create_local_user(galaxy_user, galaxy_user_email, galaxy_password)
            galaxy_user_id = new_user["id"]

        api_key = gi.users.create_user_apikey(galaxy_user_id)
        os.environ["BIOBLEND_GALAXY_API_KEY"] = api_key

    if 'BIOBLEND_GALAXY_API_KEY' not in os.environ:
        return unittest.skip(NO_GALAXY_MESSAGE)

    return lambda f: f

 def test_chown(self) :
     if not is_privileged :
         LogFile.write("skipping %s...\n" % inspect.stack()[0][3])
         unittest.skip("rpc-server not running as privileged user")
         return
     LogFile.write("testing %s...\n" % inspect.stack()[0][3])
     res = proxy.hpss_chown("%s/%s" % (hpss_test_dir, hpss_test_file) ,{}, 63232, 63232)
     LogFile.write("res=%s\n\n" % res)
     self.assertEqual(proxy.check_error(res)[1], "")

 def test_negative_update_my_account_2(self):
     """
     @Feature: My Account - Negative Update
     @Test: Update My Account with invalid Surname
     @Steps:
     1. Update Current user with all variations of Surname in [2]
     @Assert: User is not updated. Appropriate error shown.
     @Status: Manual
     """
     unittest.skip(NOT_IMPLEMENTED)

 def test_getdatabase_postgres_nohostname_noport_setdefault(self):
     """Check get_database set default hostname and port for MySQL"""
     try:
         db = AccessionID(dbname='taxadb', dbtype='postgres',
                          password="admin",
                          username="admin")
         self.assertEqual(int(db.get('port')), 5432)
         self.assertEqual(db.get('hostname'), 'localhost')
     except SystemExit as err:
         unittest.skip("Can't test function: %s" % str(err))

 def test_positive_update_my_account_5(self):
     """
     @Feature: My Account - Positive Update
     @Test: Update Password/Verify fields in My Account
     @Steps:
     1. Update Password/Verify fields with all variations in [1]
     @Assert: User is updated
     @Status: Manual
     """
     unittest.skip(NOT_IMPLEMENTED)