This will verify that all mocks so far have been satisfied. It will clear
the set of outstanding mocks, regardless if any have failed.
@return void
775419
public static function verify()
    {
        $mocks = self::$outstanding_shmocks;
        self::$outstanding_shmocks = [];
        foreach ($mocks as $mock) {
            $mock->verify();
        }
    }
392545
public function flush()
    {
        // Prevent an endless loop and work on a batch copy.
        $promises = $this->getPromises();
        $this->setPromises([]);
        Promise\settle($promises)->wait();
    }
523618
protected function checkRequirements()
    {
        $this->verifyFieldRequirements();

        $this->verifyFieldValuesRequirements();

        $this->verifyGroupRequirements();

        $this->verifyConditionalRequirements();

        $this->verifyConditionalFields();
    }
1015875
public function clear()
    {
        $this->id = null;
        $this->file = null;
        $this->person_id = null;
        $this->visible = null;
        $this->position = null;
        $this->created_at = null;
        $this->updated_at = null;
        $this->alreadyInSave = false;
        $this->clearAllReferences();
        $this->applyDefaultValues();
        $this->resetModified();
        $this->setNew(true);
        $this->setDeleted(false);
    }
1114091
public function flush()
    {
        $this->initializeOnDemand();

        if ($this->cacheMapper->flush()) {
            // Reset the current state as well
            $this->cache = array();
            return true;
        } else {
            return false;
        }
    }
360773
public function clear()
    {
        if (null !== $this->aSkill) {
            $this->aSkill->removeSkillReference($this);
        }
        if (null !== $this->aReference) {
            $this->aReference->removeSkillReference($this);
        }
        $this->skill_id = null;
        $this->reference_id = null;
        $this->alreadyInSave = false;
        $this->clearAllReferences();
        $this->resetModified();
        $this->setNew(true);
        $this->setDeleted(false);
    }
1327014
public function clear()
    {
        $this->id = null;
        $this->created_at = null;
        $this->updated_at = null;
        $this->alreadyInSave = false;
        $this->clearAllReferences();
        $this->resetModified();
        $this->setNew(true);
        $this->setDeleted(false);
    }
333471
public function clear()
    {
        $this->id = null;
        $this->dt_call = null;
        $this->remote_app_id = null;
        $this->statuscode = null;
        $this->last_response = null;
        $this->alreadyInSave = false;
        $this->alreadyInValidation = false;
        $this->alreadyInClearAllReferencesDeep = false;
        $this->clearAllReferences();
        $this->resetModified();
        $this->setNew(true);
        $this->setDeleted(false);
    }
1233500
public function clear()
    {
        $this->assertOpened();
        foreach ($this->contents as $key => $value) {
            unset($this->contents[$key]);
        }
    }
1291538
public function clean()
	{
		if ($this->output->isInteractive())
		{
			$performed = 0;
			$proceed   = $this->output->getResponse('Do you want to purge all rollback points except the latest? [y|n]');

			if ($proceed == 'y' || $proceed == 'yes')
			{
				$this->mechanism->purgeRollbackPoints();
				$this->output->addLine('Purging rollback points.');
				$performed++;
			}

			$proceed = $this->output->getResponse('Do you want to purge all stashed changes? [y|n]');

			if ($proceed == 'y' || $proceed == 'yes')
			{
				$this->mechanism->purgeStash();
				$this->output->addLine('Purging repository stash.');
				$performed++;
			}

			$this->output->addLine("Clean up complete. Performed ({$performed}/2) cleanup operations available.");
		}
		else
		{
			$didSomething = false;
			if ($this->arguments->getOpt('purge-rollback-points'))
			{
				$this->mechanism->purgeRollbackPoints();
				$this->output->addLine('Purging rollback points.');
				$didSomething = true;
			}

			if ($this->arguments->getOpt('purge-stash'))
			{
				$this->mechanism->purgeStash();
				$this->output->addLine('Purging repository stash.');
				$didSomething = true;
			}

			if (!$didSomething)
			{
				$this->output->addLine('Please specify which cleanup operations to perform');
			}
		}
	}
673760
public function finish()
    {
        if (!empty($this->queue)) {
            // empty queue to avoid duplicates
            $queue = $this->queue;
            $this->queue = array();
            $this->sendChunk($queue);
        }
    }
781461
protected function clear() {
    foreach ($this->newObjects as $object) {
      unset($this->observedObjects[$object->getOID()->__toString()]);
    }
    $this->newObjects = [];

    foreach ($this->dirtyObjects as $object) {
      unset($this->observedObjects[$object->getOID()->__toString()]);
    }
    $this->dirtyObjects = [];

    foreach ($this->deletedObjects as $object) {
      unset($this->observedObjects[$object->getOID()->__toString()]);
    }
    $this->deletedObjects = [];

    foreach ($this->loadedObjects as $object) {
      unset($this->observedObjects[$object->getOID()->__toString()]);
    }
    $this->loadedObjects = [];

    $this->detachedObjects = [];
  }
170027
protected function check(): void
    {
        $check = $this->check;

        for ($i = 0; $i <= $this->iterations; $i++) {
            $result = $check($this->value);
            if ($result !== false) {
                $this->deferred->resolve($result);

                return;
            }
        }

        futurePromise($this->loop)->then(function (): void {
            $this->check();
        });
    }
31276
public function clear()
    {
        $this->id = null;
        $this->name = null;
        $this->street = null;
        $this->zip = null;
        $this->city = null;
        $this->country_id = null;
        $this->phone = null;
        $this->fax = null;
        $this->email = null;
        $this->legalform = null;
        $this->logo = null;
        $this->created = null;
        $this->notes = null;
        $this->alreadyInSave = false;
        $this->alreadyInValidation = false;
        $this->alreadyInClearAllReferencesDeep = false;
        $this->clearAllReferences();
        $this->resetModified();
        $this->setNew(true);
        $this->setDeleted(false);
    }
16485
protected function cleanupResult () : void
    {
        // Reset state
        if ($this->_State > 2) : 
            $this->_State = 2;
        endif;

            //////

        // Clean pairwise
        $this->_Pairwise = null;

        // Algos
        $this->_Calculator = null;
    }
749634
public function clear(): void
    {
        if (!$this->overwrite) {
            return;
        }

        if (null === $this->format) {
            $this->setRealFormat($this->internalFormat ?: $this->determineBestFormat());
        }

        $this->overwrite('');
    }
1086190
public function clear()
    {
        $this->id = null;
        $this->name = null;
        $this->role = null;
        $this->alreadyInSave = false;
        $this->alreadyInValidation = false;
        $this->alreadyInClearAllReferencesDeep = false;
        $this->clearAllReferences();
        $this->resetModified();
        $this->setNew(true);
        $this->setDeleted(false);
    }