From 55764d05f33dab257b5ad43c706153e03cee79b4 Mon Sep 17 00:00:00 2001 From: Artem Ukrainskiy Date: Fri, 13 Nov 2026 05:53:29 +0000 Subject: [PATCH] ext/dom: Add Dom\XMLSchema to reuse a compiled XML Schema Dom\XMLSchema::createFromFile()/createFromString() compile the schema once, validate() checks a Dom\XMLDocument or DOMDocument with a fresh validation context. schemaValidate() now shares the compile and validate helpers. --- UPGRADING | 6 + ext/dom/document.c | 246 +++++++++++++----- ext/dom/dom_ce.h | 3 + ext/dom/php_dom.c | 8 + ext/dom/php_dom.h | 4 + ext/dom/php_dom.stub.php | 17 ++ ext/dom/php_dom_arginfo.h | 48 +++- ext/dom/php_dom_decl.h | 8 +- ext/dom/tests/modern/xml/XMLSchema_basic.phpt | 31 +++ .../tests/modern/xml/XMLSchema_errors.phpt | 37 +++ 10 files changed, 345 insertions(+), 63 deletions(-) create mode 100644 ext/dom/tests/modern/xml/XMLSchema_basic.phpt create mode 100644 ext/dom/tests/modern/xml/XMLSchema_errors.phpt diff --git a/UPGRADING b/UPGRADING index d9242ecb3c17..91d1b4912ae8 100644 --- a/UPGRADING +++ b/UPGRADING @@ -141,6 +141,12 @@ PHP 8.7 UPGRADE NOTES 7. New Classes and Interfaces ======================================== +- DOM: + . Added Dom\XMLSchema. It compiles an XML Schema once with + Dom\XMLSchema::createFromFile() or Dom\XMLSchema::createFromString(), + and Dom\XMLSchema::validate() validates a Dom\XMLDocument or DOMDocument + against it without compiling the schema again. + - Intl: . IntlRelativeDateTimeFormatter . enum IntlRelativeDateTimeFormatterStyle diff --git a/ext/dom/document.c b/ext/dom/document.c index ccb2c08bc815..45b24c450bc0 100644 --- a/ext/dom/document.c +++ b/ext/dom/document.c @@ -1873,83 +1873,65 @@ PHP_METHOD(DOMDocument, validate) /* }}} */ #ifdef LIBXML_SCHEMAS_ENABLED -static void dom_document_schema_validate(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */ +/* Compiles an XML Schema from a file path or a string. On failure returns NULL + * and either throws (throw_on_error) or emits a warning. */ +static xmlSchemaPtr dom_schema_compile(dom_load_mode mode, const char *source, size_t source_len, bool throw_on_error) { - zval *id; - xmlDoc *docp; - dom_object *intern; - char *source = NULL; - const char *valid_file = NULL; - size_t source_len = 0; - int valid_opts = 0; - zend_long flags = 0; - xmlSchemaParserCtxtPtr parser; - xmlSchemaPtr sptr; - xmlSchemaValidCtxtPtr vptr; - int is_valid; + xmlSchemaParserCtxtPtr parser; + xmlSchemaPtr sptr; char resolved_path[MAXPATHLEN + 1]; - id = ZEND_THIS; - if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &source, &source_len, &flags) == FAILURE) { - RETURN_THROWS(); - } - - if (!source_len) { - zend_argument_must_not_be_empty_error(1); - RETURN_THROWS(); - } - - DOM_GET_OBJ(docp, id, xmlDocPtr, intern); - - PHP_LIBXML_SANITIZE_GLOBALS(new_parser_ctxt); - - switch (type) { - case DOM_LOAD_FILE: - if (zend_char_has_nul_byte(source, source_len)) { - PHP_LIBXML_RESTORE_GLOBALS(new_parser_ctxt); - zend_argument_value_error(1, "must not contain any null bytes"); - RETURN_THROWS(); - } - valid_file = dom_get_valid_file_path(source, resolved_path, MAXPATHLEN); + if (mode == DOM_LOAD_FILE) { + const char *valid_file = dom_get_valid_file_path(source, resolved_path, MAXPATHLEN); if (!valid_file) { - PHP_LIBXML_RESTORE_GLOBALS(new_parser_ctxt); - php_error_docref(NULL, E_WARNING, "Invalid Schema file source"); - RETURN_FALSE; + if (throw_on_error) { + zend_throw_exception_ex(NULL, 0, "Cannot open schema file '%s'", source); + } else { + php_error_docref(NULL, E_WARNING, "Invalid Schema file source"); + } + return NULL; } + PHP_LIBXML_SANITIZE_GLOBALS(new_parser_ctxt); parser = xmlSchemaNewParserCtxt(valid_file); - break; - case DOM_LOAD_STRING: - parser = xmlSchemaNewMemParserCtxt(source, source_len); + PHP_LIBXML_RESTORE_GLOBALS(new_parser_ctxt); + } else { /* If loading from memory, we need to set the base directory for the document but it is not apparent how to do that for schema's */ - break; - default: - return; + PHP_LIBXML_SANITIZE_GLOBALS(new_parser_ctxt); + parser = xmlSchemaNewMemParserCtxt(source, source_len); + PHP_LIBXML_RESTORE_GLOBALS(new_parser_ctxt); } + PHP_LIBXML_SANITIZE_GLOBALS(parse); xmlSchemaSetParserErrors(parser, (xmlSchemaValidityErrorFunc) php_libxml_error_handler, (xmlSchemaValidityWarningFunc) php_libxml_error_handler, parser); sptr = xmlSchemaParse(parser); xmlSchemaFreeParserCtxt(parser); - PHP_LIBXML_RESTORE_GLOBALS(new_parser_ctxt); - if (!sptr) { - if (!EG(exception)) { + PHP_LIBXML_RESTORE_GLOBALS(parse); + + if (!sptr && !EG(exception)) { + if (throw_on_error) { + zend_throw_exception(NULL, "Invalid Schema", 0); + } else { php_error_docref(NULL, E_WARNING, "Invalid Schema"); } - RETURN_FALSE; } + return sptr; +} - docp = (xmlDocPtr) dom_object_get_node(intern); - - vptr = xmlSchemaNewValidCtxt(sptr); +/* Validates docp against a compiled schema with a fresh validation context. + * Returns true if the document is valid. Throws if the context cannot be created. */ +static bool dom_schema_validate_doc(xmlSchemaPtr sptr, xmlDocPtr docp, zend_long flags) +{ + xmlSchemaValidCtxtPtr vptr = xmlSchemaNewValidCtxt(sptr); if (!vptr) { - xmlSchemaFree(sptr); zend_throw_error(NULL, "Invalid Schema Validation Context"); - RETURN_THROWS(); + return false; } + int valid_opts = 0; if (flags & XML_SCHEMA_VAL_VC_I_CREATE) { valid_opts |= XML_SCHEMA_VAL_VC_I_CREATE; } @@ -1959,17 +1941,50 @@ static void dom_document_schema_validate(INTERNAL_FUNCTION_PARAMETERS, int type) xmlSchemaSetValidErrors(vptr, php_libxml_error_handler, php_libxml_error_handler, vptr); dom_validate_ns_guard guard; dom_validate_ns_guard_begin(&guard, docp); - is_valid = xmlSchemaValidateDoc(vptr, docp); + int is_valid = xmlSchemaValidateDoc(vptr, docp); dom_validate_ns_guard_end(&guard); - xmlSchemaFree(sptr); xmlSchemaFreeValidCtxt(vptr); PHP_LIBXML_RESTORE_GLOBALS(validate); - if (is_valid == 0) { - RETURN_TRUE; - } else { + return is_valid == 0; +} + +static void dom_document_schema_validate(INTERNAL_FUNCTION_PARAMETERS, dom_load_mode mode) /* {{{ */ +{ + xmlDoc *docp; + dom_object *intern; + char *source = NULL; + size_t source_len = 0; + zend_long flags = 0; + + if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &source, &source_len, &flags) == FAILURE) { + RETURN_THROWS(); + } + + if (!source_len) { + zend_argument_must_not_be_empty_error(1); + RETURN_THROWS(); + } + + DOM_GET_OBJ(docp, ZEND_THIS, xmlDocPtr, intern); + + if (mode == DOM_LOAD_FILE && zend_char_has_nul_byte(source, source_len)) { + zend_argument_value_error(1, "must not contain any null bytes"); + RETURN_THROWS(); + } + + xmlSchemaPtr sptr = dom_schema_compile(mode, source, source_len, false); + if (!sptr) { RETURN_FALSE; } + + docp = (xmlDocPtr) dom_object_get_node(intern); + bool is_valid = dom_schema_validate_doc(sptr, docp, flags); + xmlSchemaFree(sptr); + if (EG(exception)) { + RETURN_THROWS(); + } + RETURN_BOOL(is_valid); } /* }}} */ @@ -2087,6 +2102,121 @@ PHP_METHOD(DOMDocument, relaxNGValidateSource) } /* }}} end dom_document_relaxNG_validate_xml */ +/* Dom\XMLSchema: a compiled XML Schema that validates many documents. */ +typedef struct { + xmlSchemaPtr schema; + zend_object std; +} dom_xml_schema_object; + +static zend_object_handlers dom_xml_schema_object_handlers; + +static inline dom_xml_schema_object *dom_xml_schema_from_obj(zend_object *obj) +{ + return (dom_xml_schema_object *) ((char *) obj - offsetof(dom_xml_schema_object, std)); +} + +static zend_object *dom_xml_schema_new(zend_class_entry *ce) +{ + dom_xml_schema_object *intern = zend_object_alloc(sizeof(dom_xml_schema_object), ce); + zend_object_std_init(&intern->std, ce); + object_properties_init(&intern->std, ce); + return &intern->std; +} + +static void dom_xml_schema_free(zend_object *obj) +{ + dom_xml_schema_object *intern = dom_xml_schema_from_obj(obj); + if (intern->schema) { + xmlSchemaFree(intern->schema); + } + zend_object_std_dtor(obj); +} + +void dom_xml_schema_init_class(zend_class_entry *ce) +{ + memcpy(&dom_xml_schema_object_handlers, &std_object_handlers, sizeof(zend_object_handlers)); + dom_xml_schema_object_handlers.offset = offsetof(dom_xml_schema_object, std); + dom_xml_schema_object_handlers.free_obj = dom_xml_schema_free; + dom_xml_schema_object_handlers.clone_obj = NULL; + ce->create_object = dom_xml_schema_new; + ce->default_object_handlers = &dom_xml_schema_object_handlers; +} + +static void dom_xml_schema_create(INTERNAL_FUNCTION_PARAMETERS, dom_load_mode mode) +{ + char *source; + size_t source_len; + + if (mode == DOM_LOAD_FILE) { + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_PATH(source, source_len) + ZEND_PARSE_PARAMETERS_END(); + } else { + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_STRING(source, source_len) + ZEND_PARSE_PARAMETERS_END(); + } + + if (!source_len) { + zend_argument_must_not_be_empty_error(1); + RETURN_THROWS(); + } + + xmlSchemaPtr sptr = dom_schema_compile(mode, source, source_len, true); + if (!sptr) { + RETURN_THROWS(); + } + + object_init_ex(return_value, dom_xml_schema_class_entry); + dom_xml_schema_from_obj(Z_OBJ_P(return_value))->schema = sptr; +} + +PHP_METHOD(Dom_XMLSchema, __construct) +{ + zend_throw_error(NULL, "Cannot directly construct %pS, use createFromFile() or createFromString() instead", Z_OBJCE_P(ZEND_THIS)->name); +} + +PHP_METHOD(Dom_XMLSchema, createFromFile) +{ + dom_xml_schema_create(INTERNAL_FUNCTION_PARAM_PASSTHRU, DOM_LOAD_FILE); +} + +PHP_METHOD(Dom_XMLSchema, createFromString) +{ + dom_xml_schema_create(INTERNAL_FUNCTION_PARAM_PASSTHRU, DOM_LOAD_STRING); +} + +PHP_METHOD(Dom_XMLSchema, validate) +{ + zval *document; + zend_long flags = 0; + xmlDocPtr docp; + dom_object *intern; + + ZEND_PARSE_PARAMETERS_START(1, 2) + Z_PARAM_OBJECT(document) + Z_PARAM_OPTIONAL + Z_PARAM_LONG(flags) + ZEND_PARSE_PARAMETERS_END(); + + if (!instanceof_function(Z_OBJCE_P(document), dom_xml_document_class_entry) + && !instanceof_function(Z_OBJCE_P(document), dom_document_class_entry)) { + zend_argument_type_error(1, "must be of type Dom\\XMLDocument|DOMDocument, %s given", zend_zval_value_name(document)); + RETURN_THROWS(); + } + + DOM_GET_OBJ(docp, document, xmlDocPtr, intern); + + dom_xml_schema_object *schema = dom_xml_schema_from_obj(Z_OBJ_P(ZEND_THIS)); + ZEND_ASSERT(schema->schema != NULL); + + bool is_valid = dom_schema_validate_doc(schema->schema, docp, flags); + if (EG(exception)) { + RETURN_THROWS(); + } + RETURN_BOOL(is_valid); +} + #endif static void dom_load_html(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */ diff --git a/ext/dom/dom_ce.h b/ext/dom/dom_ce.h index 8959d6013c7b..b2ab5f30c4bc 100644 --- a/ext/dom/dom_ce.h +++ b/ext/dom/dom_ce.h @@ -65,6 +65,9 @@ extern PHP_DOM_EXPORT zend_class_entry *dom_token_list_class_entry; extern PHP_DOM_EXPORT zend_class_entry *dom_xpath_class_entry; extern PHP_DOM_EXPORT zend_class_entry *dom_modern_xpath_class_entry; #endif +#ifdef LIBXML_SCHEMAS_ENABLED +extern PHP_DOM_EXPORT zend_class_entry *dom_xml_schema_class_entry; +#endif extern PHP_DOM_EXPORT zend_class_entry *dom_namespace_node_class_entry; extern PHP_DOM_EXPORT zend_class_entry *dom_adjacent_position_class_entry; extern PHP_DOM_EXPORT zend_class_entry *dom_namespace_info_class_entry; diff --git a/ext/dom/php_dom.c b/ext/dom/php_dom.c index 0833d9a3c9be..191770fa9fa6 100644 --- a/ext/dom/php_dom.c +++ b/ext/dom/php_dom.c @@ -79,6 +79,9 @@ PHP_DOM_EXPORT zend_class_entry *dom_modern_entityreference_class_entry; PHP_DOM_EXPORT zend_class_entry *dom_processinginstruction_class_entry; PHP_DOM_EXPORT zend_class_entry *dom_modern_processinginstruction_class_entry; PHP_DOM_EXPORT zend_class_entry *dom_abstract_base_document_class_entry; +#ifdef LIBXML_SCHEMAS_ENABLED +PHP_DOM_EXPORT zend_class_entry *dom_xml_schema_class_entry; +#endif PHP_DOM_EXPORT zend_class_entry *dom_token_list_class_entry; #ifdef LIBXML_XPATH_ENABLED PHP_DOM_EXPORT zend_class_entry *dom_xpath_class_entry; @@ -1355,6 +1358,11 @@ PHP_MINIT_FUNCTION(dom) zend_hash_add_new_ptr(&classes, dom_modern_xpath_class_entry->name, &dom_xpath_prop_handlers); #endif +#ifdef LIBXML_SCHEMAS_ENABLED + dom_xml_schema_class_entry = register_class_Dom_XMLSchema(); + dom_xml_schema_init_class(dom_xml_schema_class_entry); +#endif + dom_token_list_class_entry = register_class_Dom_TokenList(zend_ce_aggregate, zend_ce_countable); dom_token_list_class_entry->create_object = dom_token_list_new; dom_token_list_class_entry->default_object_handlers = &dom_token_list_object_handlers; diff --git a/ext/dom/php_dom.h b/ext/dom/php_dom.h index 24475022e614..b79d0a2cbeda 100644 --- a/ext/dom/php_dom.h +++ b/ext/dom/php_dom.h @@ -179,6 +179,10 @@ typedef enum { #define DOM_DOCUMENT_MALFORMED ((xmlDocPtr) -1) +#ifdef LIBXML_SCHEMAS_ENABLED +void dom_xml_schema_init_class(zend_class_entry *ce); +#endif + xmlDocPtr dom_document_parser(zval *id, dom_load_mode mode, const char *source, size_t source_len, size_t options, xmlCharEncodingHandlerPtr encoding); /* parentnode */ diff --git a/ext/dom/php_dom.stub.php b/ext/dom/php_dom.stub.php index 521e3cd99c2e..bf6b0122aa0f 100644 --- a/ext/dom/php_dom.stub.php +++ b/ext/dom/php_dom.stub.php @@ -1797,5 +1797,22 @@ public static function quote(string $str): string {} } #endif +#ifdef LIBXML_SCHEMAS_ENABLED + /** + * @strict-properties + * @not-serializable + */ + final class XMLSchema + { + private function __construct() {} + + public static function createFromFile(string $path): XMLSchema {} + + public static function createFromString(string $source): XMLSchema {} + + public function validate(XMLDocument|\DOMDocument $document, int $flags = 0): bool {} + } +#endif + function import_simplexml(object $node): Attr|Element {} } diff --git a/ext/dom/php_dom_arginfo.h b/ext/dom/php_dom_arginfo.h index 6a15f911e610..31a69e1aa87f 100644 --- a/ext/dom/php_dom_arginfo.h +++ b/ext/dom/php_dom_arginfo.h @@ -1,5 +1,5 @@ /* This is a generated file, edit php_dom.stub.php instead. - * Stub hash: 8d7713834c924709155ed7acc554c9efc55e96c1 + * Stub hash: 320f3926174801d208af4045a0b7844ff51de957 * Has decl header: yes */ #include "zend_attributes.h" @@ -1134,6 +1134,24 @@ ZEND_END_ARG_INFO() #define arginfo_class_Dom_XPath_quote arginfo_class_DOMXPath_quote #endif +#if defined(LIBXML_SCHEMAS_ENABLED) +ZEND_BEGIN_ARG_INFO_EX(arginfo_class_Dom_XMLSchema___construct, 0, 0, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_class_Dom_XMLSchema_createFromFile, 0, 1, Dom\\XMLSchema, 0) + ZEND_ARG_TYPE_INFO(0, path, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_class_Dom_XMLSchema_createFromString, 0, 1, Dom\\XMLSchema, 0) + ZEND_ARG_TYPE_INFO(0, source, IS_STRING, 0) +ZEND_END_ARG_INFO() + +ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_Dom_XMLSchema_validate, 0, 1, _IS_BOOL, 0) + ZEND_ARG_OBJ_TYPE_MASK(0, document, Dom\\XMLDocument|DOMDocument, 0, NULL) + ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "0") +ZEND_END_ARG_INFO() +#endif + ZEND_FUNCTION(dom_import_simplexml); ZEND_FUNCTION(Dom_import_simplexml); ZEND_METHOD(DOMCdataSection, __construct); @@ -1329,6 +1347,12 @@ ZEND_METHOD(Dom_XPath, __construct); ZEND_METHOD(Dom_XPath, evaluate); ZEND_METHOD(Dom_XPath, query); #endif +#if defined(LIBXML_SCHEMAS_ENABLED) +ZEND_METHOD(Dom_XMLSchema, __construct); +ZEND_METHOD(Dom_XMLSchema, createFromFile); +ZEND_METHOD(Dom_XMLSchema, createFromString); +ZEND_METHOD(Dom_XMLSchema, validate); +#endif static const zend_function_entry ext_functions[] = { ZEND_FE(dom_import_simplexml, arginfo_dom_import_simplexml) @@ -1809,6 +1833,16 @@ static const zend_function_entry class_Dom_XPath_methods[] = { }; #endif +#if defined(LIBXML_SCHEMAS_ENABLED) +static const zend_function_entry class_Dom_XMLSchema_methods[] = { + ZEND_ME(Dom_XMLSchema, __construct, arginfo_class_Dom_XMLSchema___construct, ZEND_ACC_PRIVATE) + ZEND_ME(Dom_XMLSchema, createFromFile, arginfo_class_Dom_XMLSchema_createFromFile, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) + ZEND_ME(Dom_XMLSchema, createFromString, arginfo_class_Dom_XMLSchema_createFromString, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC) + ZEND_ME(Dom_XMLSchema, validate, arginfo_class_Dom_XMLSchema_validate, ZEND_ACC_PUBLIC) + ZEND_FE_END +}; +#endif + static void register_php_dom_symbols(int module_number) { REGISTER_LONG_CONSTANT("XML_ELEMENT_NODE", XML_ELEMENT_NODE, CONST_PERSISTENT); @@ -3629,3 +3663,15 @@ static zend_class_entry *register_class_Dom_XPath(void) return class_entry; } #endif + +#if defined(LIBXML_SCHEMAS_ENABLED) +static zend_class_entry *register_class_Dom_XMLSchema(void) +{ + zend_class_entry ce, *class_entry; + + INIT_NS_CLASS_ENTRY(ce, "Dom", "XMLSchema", class_Dom_XMLSchema_methods); + class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NO_DYNAMIC_PROPERTIES|ZEND_ACC_NOT_SERIALIZABLE); + + return class_entry; +} +#endif diff --git a/ext/dom/php_dom_decl.h b/ext/dom/php_dom_decl.h index e42fe5969595..7bc556994676 100644 --- a/ext/dom/php_dom_decl.h +++ b/ext/dom/php_dom_decl.h @@ -1,8 +1,8 @@ /* This is a generated file, edit php_dom.stub.php instead. - * Stub hash: 8d7713834c924709155ed7acc554c9efc55e96c1 */ + * Stub hash: 320f3926174801d208af4045a0b7844ff51de957 */ -#ifndef ZEND_PHP_DOM_DECL_8d7713834c924709155ed7acc554c9efc55e96c1_H -#define ZEND_PHP_DOM_DECL_8d7713834c924709155ed7acc554c9efc55e96c1_H +#ifndef ZEND_PHP_DOM_DECL_320f3926174801d208af4045a0b7844ff51de957_H +#define ZEND_PHP_DOM_DECL_320f3926174801d208af4045a0b7844ff51de957_H typedef enum zend_enum_Dom_AdjacentPosition { ZEND_ENUM_Dom_AdjacentPosition_BeforeBegin = 1, @@ -11,4 +11,4 @@ typedef enum zend_enum_Dom_AdjacentPosition { ZEND_ENUM_Dom_AdjacentPosition_AfterEnd = 4, } zend_enum_Dom_AdjacentPosition; -#endif /* ZEND_PHP_DOM_DECL_8d7713834c924709155ed7acc554c9efc55e96c1_H */ +#endif /* ZEND_PHP_DOM_DECL_320f3926174801d208af4045a0b7844ff51de957_H */ diff --git a/ext/dom/tests/modern/xml/XMLSchema_basic.phpt b/ext/dom/tests/modern/xml/XMLSchema_basic.phpt new file mode 100644 index 000000000000..7a2550faf0f5 --- /dev/null +++ b/ext/dom/tests/modern/xml/XMLSchema_basic.phpt @@ -0,0 +1,31 @@ +--TEST-- +Dom\XMLSchema: compile once, validate several documents +--EXTENSIONS-- +dom +--FILE-- +load(__DIR__ . '/../../book.xml'); +$modern = Dom\XMLDocument::createFromFile(__DIR__ . '/../../book.xml'); +$invalid = Dom\XMLDocument::createFromString('T'); + +var_dump($schema->validate($legacy)); +var_dump($schema->validate($modern)); +var_dump($fromString->validate($modern)); + +libxml_use_internal_errors(true); +var_dump($schema->validate($invalid)); +var_dump(count(libxml_get_errors()) > 0); +libxml_clear_errors(); +var_dump($schema->validate($modern)); +?> +--EXPECT-- +bool(true) +bool(true) +bool(true) +bool(false) +bool(true) +bool(true) diff --git a/ext/dom/tests/modern/xml/XMLSchema_errors.phpt b/ext/dom/tests/modern/xml/XMLSchema_errors.phpt new file mode 100644 index 000000000000..816029173323 --- /dev/null +++ b/ext/dom/tests/modern/xml/XMLSchema_errors.phpt @@ -0,0 +1,37 @@ +--TEST-- +Dom\XMLSchema: construction and argument errors +--EXTENSIONS-- +dom +--FILE-- + new Dom\XMLSchema(), + fn() => clone $schema, + fn() => serialize($schema), + fn() => Dom\XMLSchema::createFromString(''), + fn() => Dom\XMLSchema::createFromFile("a\0b"), + fn() => @Dom\XMLSchema::createFromString(''), + fn() => @Dom\XMLSchema::createFromFile(__DIR__ . '/does-not-exist.xsd'), + fn() => $schema->validate(new stdClass()), + fn() => $schema->validate(Dom\HTMLDocument::createEmpty()), +]; +foreach ($cases as $case) { + try { + $case(); + echo "no exception\n"; + } catch (Throwable $e) { + echo $e::class, ': ', $e->getMessage(), "\n"; + } +} +?> +--EXPECT-- +Error: Call to private Dom\XMLSchema::__construct() from global scope +Error: Trying to clone an uncloneable object of class Dom\XMLSchema +Exception: Serialization of 'Dom\XMLSchema' is not allowed +ValueError: Dom\XMLSchema::createFromString(): Argument #1 ($source) must not be empty +ValueError: Dom\XMLSchema::createFromFile(): Argument #1 ($path) must not contain any null bytes +Exception: Invalid Schema +Exception: Invalid Schema +TypeError: Dom\XMLSchema::validate(): Argument #1 ($document) must be of type Dom\XMLDocument|DOMDocument, stdClass given +TypeError: Dom\XMLSchema::validate(): Argument #1 ($document) must be of type Dom\XMLDocument|DOMDocument, Dom\HTMLDocument given