def tearDownClass(self):
     try:
         self.apiclient = super(TestvGPUWindowsVm, self).getClsTestClient().getApiClient()
         cleanup_resources(self.apiclient, self._cleanup)
     except Exception as e:
         raise Exception("Warning: Exception during cleanup : %s" % e)
     return

 def tearDownClass(cls):
    try:
       cleanup_resources(cls.api_client, cls._proj_toclean)
       cleanup_resources(cls.api_client, cls._cleanup)
       cls.domain.delete(cls.api_client, cleanup=True)
    except Exception as e:
       raise Exception("Warning: Exception during cleanup : %s" % e)

    def tearDownClass(cls):
        try:
            cleanup_resources(cls.apiClient, cls._cleanup)

            cls.primary_storage.delete(cls.apiClient)
        except Exception as e:
            logging.debug("Exception in tearDownClass(cls): %s" % e)

 def tearDown(self):
     try:
         self.logger.debug("Cleaning up resources")
         self.cleanup.reverse()
         cleanup_resources(self.apiclient, self.cleanup, self.logger)
     except Exception as e:
         raise Exception("Cleanup failed with %s" % e)

    def tearDownClass(cls):
        try:
            cleanup_resources(cls.apiClient, cls._cleanup)

            cls._purge_solidfire_volumes()
        except Exception as e:
            logging.debug("Exception in tearDownClass(cls): %s" % e)

 def tearDown(self):
     try:
         self.entity_manager.destroy_routers()
         cleanup_resources(self.apiclient, self.cleanup)
     except Exception as e:
         raise Exception("Warning: Exception during cleanup : %s" % e)
     return

 def tearDownClass(cls):
     try:
         #Clean up, terminate the created resources
         cleanup_resources(cls.api_client, cls._cleanup)
     except Exception as e:
         raise Exception("Warning: Exception during cleanup : %s" % e)
     return

 def tearDown(self):
     try:
         # Clean up, terminate the created instance, volumes and snapshots
         cleanup_resources(self.apiclient, self.cleanup)
     except Exception as e:
         raise Exception("Warning: Exception during cleanup : %s" % e)
     return

    def tearDownClass(cls):

        try:
            cls.logger.debug("Cleaning up resources")
            cleanup_resources(cls.apiclient, cls.cleanup)
        except Exception, e:
            raise Exception("Cleanup failed with %s" % e)

 def tearDown(self):
     try:
         self.account.delete(self.apiclient)
         cleanup_resources(self.apiclient, self.cleanup)
     except Exception as e:
         raise Exception("Warning: Exception during cleanup : %s" % e)
     return

    def tearDown(self):

        try:
            cleanup_resources(self.api_client, self.method_cleanup, self.logger)

        except Exception as e:
            raise Exception("Exception: %s" % e)

 def tearDown(self):
     try:
         self.debug("Cleaning up the resources")
         cleanup_resources(self.apiclient, reversed(self.cleanup))
         self.debug("Cleanup complete!")
     except Exception as e:
         self.debug("Warning! Exception in tearDown: %s" % e)

 def tearDownClass(cls):
     try:
         cls.apiclient = super(TestVpcRemoteAccessVpn, cls).getClsTestClient().getApiClient()
         cleanup_resources(cls.apiclient, cls._cleanup)
     except Exception as e:
         raise Exception("Warning: Exception during cleanup : %s" % e)
     return

 def tearDown(self):
     try:
         cleanup_resources(self.apiclient, self.cleanup)
     except Exception as e:
         self.debug("Warning: Exception during cleanup : %s" % e)
         # raise Exception("Warning: Exception during cleanup : %s" % e)
     return

    def tearDown(self):
        try:
            for storagePool in self.pools:
                StoragePool.update(self.apiclient, id=storagePool.id, tags="")

            if hasattr(self, "data_volume_created"):
                data_volumes_list = Volume.list(
                    self.userapiclient,
                    id=self.data_volume_created.id,
                    virtualmachineid=self.vm.id
                )
                if data_volumes_list:
                    self.vm.detach_volume(
                        self.userapiclient,
                        data_volumes_list[0]
                    )

                status = validateList(data_volumes_list)
                self.assertEqual(
                    status[0],
                    PASS,
                    "DATA Volume List Validation Failed")

            cleanup_resources(self.apiclient, self.cleanup)
        except Exception as e:
            raise Exception("Warning: Exception during cleanup : %s" % e)
        return

 def tearDownClass(cls):
    try:
       #Clean up, terminate the created templates
       cls.domain.delete(cls.api_client, cleanup=True)
       cleanup_resources(cls.api_client, cls._cleanup)
    except Exception as e:
       raise Exception("Warning: Exception during cleanup : %s" % e)

 def tearDownClass(cls):
     cls.apiclient = super(TestVMLifeCycle, cls).getClsTestClient().getApiClient()
     try:
         cleanup_resources(cls.apiclient, cls._cleanup)
     except Exception as e:
         raise Exception("Warning: Exception during cleanup : %s" % e)
     return

    def tearDownClass(cls):

        try:
            cleanup_resources(cls.api_client, cls.class_cleanup, cls.logger)

        except Exception as e:
            raise Exception("Exception: %s" % e)

 def tearDown(self):
     try:
         self.destroy_routers()
         cleanup_resources(self.apiclient, self.cleanup)
     except Exception as e:
         self.logger.debug("Warning: Exception during cleanup : %s" % e)
     return

    def tearDownClass(cls):
        try:
            # Cleanup resources used

            if cls.updateclone:
                Configurations.update(cls.api_client,
                                      "vmware.create.full.clone",
                                      value="false",storageid=cls.storageID)
                Configurations.update(cls.api_client,
                                              "vmware.create.full.clone",
                                              value="false")
                Configurations.update(cls.api_client,
                                              "vmware.root.disk.controller",
                                              value=cls.defaultdiskcontroller)
                StoragePool.update(cls.api_client, id=cls.storageID,
                                   tags="")
                cls.restartServer()

                #Giving 30 seconds to management to warm-up,
                #Experienced failures when trying to deploy a VM exactly when management came up
                time.sleep(30)

            cleanup_resources(cls.api_client, cls._cleanup)
        except Exception as e:
            raise Exception("Warning: Exception during cleanup : %s" % e)
        return