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 tearDown(self):
     try:
         #Clean up, terminate the created network offerings
         cleanup_resources(self.apiclient, self.cleanup)
     except Exception as e:
         self.debug("Warning: Exception during cleanup : %s" % e)
     return

 def tearDownClass(cls):
     try:
         # Cleanup resources used
         cleanup_resources(cls.api_client, cls._cleanup)
     except Exception as e:
         raise Exception("Warning: Exception during cleanup : %s" % e)
     return

 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 tearDown(self):
     try:
         # Clean up, terminate the resources created
         cleanup_resources(self.apiclient, self.cleanup)
         self.cleanup[:] = []
     except Exception as e:
         raise Exception("Warning: Exception during cleanup : %s" % e)
     return

    def tearDownClass(cls):
        try:
            cls.api_client = super(TestServiceOfferings, cls).getClsTestClient().getApiClient()
            #Clean up, terminate the created templates
            cleanup_resources(cls.api_client, cls._cleanup)

        except Exception as e:
            raise Exception("Warning: Exception during cleanup : %s" % e)
        return

    def tearDown(self):
        """
        Teardown to update a physical network and shrink its vlan
        Cleanup all used resource
        """
        self.physicalnetwork.update(self.apiClient, id = self.physicalnetworkid, vlan=self.existingvlan)

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

    def tearDown(self):
        try:
            # Clean up compute offerings
            cleanup_resources(self.apiclient, self.cleanup)

            # Clean up compute offerings
            cleanup_resources(self.apiclient, self.cleanup_co)

            self.cleanup_co[:] = []
            self.cleanup[:] = []
        except Exception as e:
            raise Exception("Warning: Exception during cleanup : %s" % e)
        return

    def tearDown(self):
        try:
            if self.egressruleid:
                self.debug('remove egress rule id=%s' % self.egressruleid)
                self.deleteEgressRule()

            self.debug("Cleaning up the resources")

            #below components is not a part of cleanup because to mandate the order and to cleanup network
            try:
                for vm in self.cleanup_vms:
                    if str(vm.state).lower() != "error":
                        vm.delete(self.api_client)
            except Exception as e:
                self.fail("Warning: Exception during virtual machines cleanup : %s" % e)

            # Wait for VMs to expunge
            wait_for_cleanup(self.api_client, ["expunge.delay", "expunge.interval"])

            if len(self.cleanup_vms) > 0:
                retriesCount = 10
                while True:
                    vms = list_virtual_machines(self.api_client, id=self.virtual_machine.id)
                    if vms is None:
                        break
                    elif retriesCount == 0:
                        self.fail("Failed to expunge vm even after 10 minutes")
                    time.sleep(60)
                    retriesCount -= 1

            try:
                for network in self.cleanup_networks:
                    network.delete(self.api_client)
            except Exception as e:
                self.fail("Warning: Exception during networks cleanup : %s" % e)

            self.debug("Sleep for Network cleanup to complete.")
            wait_for_cleanup(self.apiclient, ["network.gc.wait", "network.gc.interval"])

            cleanup_resources(self.apiclient, reversed(self.cleanup))
            self.debug("Cleanup complete!")
        except Exception as e:
            self.fail("Warning! Cleanup failed: %s" % e)

 def tearDownClass(cls):
     try:
         cleanup_resources(cls.apiclient, cls.cleanup)
     except Exception as e:
         raise Exception("Warning: Exception during cleanup : %s" % e)

 def tearDown(self):
     try:
         cleanup_resources(self.apiclient, self.cleanup)
     except Exception as e:
         self.debug("Warning! Exception in tearDown: %s" % e)

 def tearDown(self):
     #Clean up, terminate the created ISOs
     cleanup_resources(self.apiclient, self.cleanup)
     return

 def tearDownClass(cls):
     cls.api_client = super(TestVMLifeCycle, cls).getClsTestClient().getApiClient()
     cleanup_resources(cls.api_client, cls._cleanup)
     return