@Given (that) a Content Type does not exist with identifier :identifier

Makes sure a content type with $identifier does not exist.
If it exists deletes it.
7260
public function ensureContentTypeDoesntExist($identifier)
    {
        $contentType = $this->loadContentTypeByIdentifier($identifier, false);
        if ($contentType) {
            $this->removeContentType($contentType);
        }
    }
1037986
public function hasIdentifier($identifier)
    {
        if(!$identifier instanceof ObjectIdentifierInterface) {
            $identifier = $this->getIdentifier($identifier);
        }

        return in_array((string) $identifier, $this->__identifier_list);
    }
1218918
public function checkContentTypeGroupExistenceByIdentifier($identifier)
    {
        /** @var \eZ\Publish\API\Repository\ContentTypeService */
        $contentTypeService = $this->contentTypeService;

        // attempt to load the content type group with the identifier
        try {
            $contentTypeService->loadContentTypeGroupByIdentifier($identifier);
            return true;
        } catch (ApiExceptions\NotFoundException $e) {
            return false;
        }
    }
997142
public function identifier($identifier = null)
    {
        if (null === $identifier) {
            return $this->identifier;
        }

        $this->identifier = $identifier;
        return $this;
    }
757998
public function setIdentifier($identifier)
    {
        if ($this->identifier && $this->identifier !== $identifier) {
            throw new MappingException('Cannot map the identifier to more than one property');
        }

        $this->identifier = $identifier;
    }
1230685
public function hasIdentifier($identifier)
    {
        if(!$identifier instanceof KObjectIdentifierInterface) {
            $identifier = $this->getIdentifier($identifier);
        }

        return in_array((string) $identifier, $this->__identifier_list);
    }
871237
public function addIdentifier($identifier)
    {
        $identifiers = $this->getIdentifiers();
        array_push($identifiers, $identifier);
        $this->setIdentifiers($identifiers);
    }
502459
public function isSatisfiedBy($contentType): bool
    {
        if (!$contentType instanceof ContentType) {
            throw new InvalidArgumentException('$contentType', sprintf('Must be instance of %s', ContentType::class));
        }

        if (in_array($contentType->identifier, $this->userContentTypeIdentifier, true)) {
            return true;
        }

        foreach ($contentType->getFieldDefinitions() as $fieldDefinition) {
            if ($fieldDefinition->fieldTypeIdentifier === self::EZUSER_FIELD_TYPE_IDENTIFIER) {
                return true;
            }
        }

        return false;
    }
730886
public static function has($identifier)
    {
        list($hash, $keys) = self::_parseIdentifier($identifier);

        foreach ($keys as $key) {
            if (isset($GLOBALS['_'.$hash]) && array_key_exists($key, $GLOBALS['_'.$hash])) {
                return true;
            }
        }

        return false;
    }
1350641
public function isViolator($identifier)
    {
        $violation = false;
        foreach ($this->throttlingStrategies as $throttlingStrategy) {
            /** @var ThrottlingStrategyInterface $throttlingHandler */
            if ($throttlingStrategy->isViolator($this->name.':'.$identifier)) {
                $violation = true;
            }
        }
        return $violation;
    }
828462
public static function setIdentifierName(string $identifier): void
    {
        if (empty($identifier)) {
            throw new InvalidArgumentException("Identifier shouldn't be empty.");
        } elseif (\in_array($identifier, ['password'])) {
            throw new InvalidArgumentException("Identifier [{$identifier}] is not allowed!");
        }

        static::$identifier = $identifier;
    }
334642
public function isAsset(Content $content): bool
    {
        if ($this->contentTypeId === null) {
            $contentType = $this->contentTypeService->loadContentTypeByIdentifier(
                $this->mappings['content_type_identifier']
            );

            $this->contentTypeId = $contentType->id;
        }

        return $content->contentInfo->contentTypeId === $this->contentTypeId;
    }
471392
function (identifier) {
            return isString(identifier) ? this.__hashIdentifierToName(this.stringToIdentifier(identifier)) :
                isInstanceOf(identifier, Identifier) ? identifier.value :
                    isInstanceOf(identifier, QualifiedIdentifier) ? identifier.column :
                        isInstanceOf(identifier, AliasedExpression) ? identifier.alias : identifier;
        }
505951
public function setIdentifier($identifier)
    {
        if (is_string($identifier) === false || empty($identifier) === true) {
            throw new InvalidArgumentException(
                "The 'identifier' argument must be a non-empty string."
            );
        }
        
        $this->identifier = $identifier;
    }
251704
function storeIdentifierValue( $contentClassAttribute, $contentObjectAttribute, $identifierValue )
    {
        $value = eZIdentifierType::generateIdentifierString( $contentClassAttribute, $identifierValue );
        $contentObjectAttribute->setAttribute( 'data_text', $value );
        $contentObjectAttribute->setAttribute( 'data_int', $identifierValue );
        return true;
    }
139578
public function hasDefinition($identifier)
    {
        return isset($this->definitions[$identifier]) || isset($this->mongoIndex[$identifier]);
    }
391443
protected function checkContentTypeExistenceByIdentifier($identifier, $groupIdentifier = null)
    {
        $contentType = $this->loadContentTypeByIdentifier($identifier, false);
        if ($contentType && $groupIdentifier) {
            $contentTypeGroups = $contentType->getContentTypeGroups();
            foreach ($contentTypeGroups as $contentTypeGroup) {
                if ($contentTypeGroup->identifier == $groupIdentifier) {
                    return true;
                }
            }

            return false;
        }

        return $contentType ? true : false;
    }